์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿค– OpenAI API์™€ ํฌ๋กค๋Ÿฌ๋กœ ๋งŒ๋“œ๋Š” ๋‰ด์Šค์š”์•ฝ ์ž๋™๋ด‡ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๐Ÿค– OpenAI API์™€ ํฌ๋กค๋Ÿฌ๋กœ ๋งŒ๋“œ๋Š” ๋‰ด์Šค์š”์•ฝ ์ž๋™๋ด‡ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๋งค์ผ ์Ÿ์•„์ง€๋Š” ๋‰ด์Šค, ์ด์ œ AI๊ฐ€ ์ž๋™์œผ๋กœ ์ •๋ฆฌํ•ด๋“œ๋ฆฝ๋‹ˆ๋‹ค! ๐Ÿ’ก

๐Ÿ“ฐ ์™œ ๋‰ด์Šค์š”์•ฝ ์ž๋™๋ด‡์ด ํ•„์š”ํ• ๊นŒ?

์•ˆ๋…•! ์˜ค๋Š˜์€ ์ •๋ง ์‹ค์šฉ์ ์ด๋ฉด์„œ๋„ ์žฌ๋ฏธ์žˆ๋Š” ํ”„๋กœ์ ํŠธ๋ฅผ ํ•จ๊ป˜ ๋งŒ๋“ค์–ด๋ณผ ๊ฑฐ์•ผ. ๋ฐ”๋กœ OpenAI API์™€ ํฌ๋กค๋Ÿฌ๋ฅผ ๊ฒฐํ•ฉํ•œ ๋‰ด์Šค์š”์•ฝ ์ž๋™๋ด‡์ด์ง€! ๐ŸŽฏ

์š”์ฆ˜ ํ•˜๋ฃจ์— ์Ÿ์•„์ง€๋Š” ๋‰ด์Šค๊ฐ€ ์–ผ๋งˆ๋‚˜ ๋งŽ์€์ง€ ์•Œ์•„? ์ฃผ์š” ํฌํ„ธ ์‚ฌ์ดํŠธ๋งŒ ๋ด๋„ ์ˆ˜๋ฐฑ, ์ˆ˜์ฒœ ๊ฐœ์˜ ๊ธฐ์‚ฌ๊ฐ€ ์‹ค์‹œ๊ฐ„์œผ๋กœ ์˜ฌ๋ผ์˜ค๊ณ  ์žˆ์–ด. ์ด๊ฑธ ๋‹ค ์ฝ์œผ๋ ค๋ฉด ํ•˜๋ฃจ 24์‹œ๊ฐ„๋„ ๋ชจ์ž๋ผ์ง€. ๊ทธ๋ž˜์„œ ์šฐ๋ฆฌ๋Š” AI์˜ ํž˜์„ ๋นŒ๋ ค์„œ ์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด๋ณผ ๊ฑฐ์•ผ! ๐Ÿš€

์ด ์ž๋™๋ด‡์€ ์›น์—์„œ ๋‰ด์Šค๋ฅผ ์ž๋™์œผ๋กœ ์ˆ˜์ง‘ํ•˜๊ณ , OpenAI์˜ ๊ฐ•๋ ฅํ•œ ์–ธ์–ด๋ชจ๋ธ์„ ํ™œ์šฉํ•ด์„œ ํ•ต์‹ฌ๋งŒ ์™์™ ๋ฝ‘์•„๋‚ด๋Š” ๋˜‘๋˜‘ํ•œ ์นœ๊ตฌ์•ผ. ๊ฐœ๋ฐœ์ž๋ผ๋ฉด ๋ˆ„๊ตฌ๋‚˜ ํ•œ ๋ฒˆ์ฏค ๋งŒ๋“ค์–ด๋ณด๊ณ  ์‹ถ์—ˆ๋˜ ํ”„๋กœ์ ํŠธ์ผ ๊ฑฐ์•ผ. ๊ทธ๋ฆฌ๊ณ  ์ด๋Ÿฐ ๊ธฐ์ˆ ์„ ์ตํ˜€๋‘๋ฉด ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์ž๋™ํ™” ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•  ์ˆ˜๋„ ์žˆ์–ด! ๐Ÿ’ผ

๐ŸŽ ์ด ํ”„๋กœ์ ํŠธ๋ฅผ ํ†ตํ•ด ์–ป์„ ์ˆ˜ ์žˆ๋Š” ๊ฒƒ๋“ค:
  • โœ… ์›น ํฌ๋กค๋ง ์‹ค์ „ ๊ฒฝํ—˜
  • โœ… OpenAI API ํ™œ์šฉ ๋Šฅ๋ ฅ
  • โœ… ์ž๋™ํ™” ์‹œ์Šคํ…œ ๊ตฌ์ถ• ๋…ธํ•˜์šฐ
  • โœ… ์‹ค๋ฌด์— ๋ฐ”๋กœ ์ ์šฉ ๊ฐ€๋Šฅํ•œ ํฌํŠธํด๋ฆฌ์˜ค
  • โœ… AI ์—์ด์ „ํŠธ ๊ฐœ๋ฐœ์˜ ๊ธฐ์ดˆ
๐ŸŒ ์›น ํฌ๋กค๋Ÿฌ ๐Ÿค– OpenAI GPT ๋ชจ๋ธ ๐Ÿ“ ์š”์•ฝ ๊ฒฐ๊ณผ ๐Ÿ“Š ์ˆ˜์ง‘ ๋‹จ๊ณ„ โ€ข HTML ํŒŒ์‹ฑ โ€ข ๋ฐ์ดํ„ฐ ์ถ”์ถœ โ€ข ์ „์ฒ˜๋ฆฌ ์ž‘์—… โ€ข ๊ตฌ์กฐํ™” ๐Ÿง  ์ฒ˜๋ฆฌ ๋‹จ๊ณ„ โ€ข API ํ˜ธ์ถœ โ€ข ํ”„๋กฌํ”„ํŠธ ์—”์ง€๋‹ˆ์–ด๋ง โ€ข ์š”์•ฝ ์ƒ์„ฑ โ€ข ํ’ˆ์งˆ ๊ฒ€์ฆ ๐Ÿ’พ ์ €์žฅ ๋‹จ๊ณ„ โ€ข DB ์ €์žฅ โ€ข ํŒŒ์ผ ์ถœ๋ ฅ โ€ข ์•Œ๋ฆผ ๋ฐœ์†ก โ€ข ๋กœ๊ทธ ๊ธฐ๋ก

๐Ÿ› ๏ธ ํ”„๋กœ์ ํŠธ ์ค€๋น„ํ•˜๊ธฐ

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ? ๋จผ์ € ์šฐ๋ฆฌ๊ฐ€ ํ•„์š”ํ•œ ๋„๊ตฌ๋“ค์„ ์ค€๋น„ํ•ด์•ผ ํ•ด. ์š”๋ฆฌ๋ฅผ ํ•˜๊ธฐ ์ „์— ์žฌ๋ฃŒ๋ฅผ ์ค€๋น„ํ•˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ง์ด์•ผ! ๐Ÿณ

์ด ํ”„๋กœ์ ํŠธ๋Š” Python์„ ๊ธฐ๋ฐ˜์œผ๋กœ ์ง„ํ–‰ํ•  ๊ฑฐ์•ผ. Python์ด ์›น ํฌ๋กค๋ง๊ณผ AI ์ž‘์—…์— ๊ฐ€์žฅ ์ ํ•ฉํ•œ ์–ธ์–ด๊ฑฐ๋“ . ๋ฌผ๋ก  ๋‹ค๋ฅธ ์–ธ์–ด๋กœ๋„ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ, Python์˜ ํ’๋ถ€ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์ƒํƒœ๊ณ„๋ฅผ ํ™œ์šฉํ•˜๋ฉด ํ›จ์”ฌ ์‰ฝ๊ณ  ๋น ๋ฅด๊ฒŒ ๊ฐœ๋ฐœํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ

๐Ÿ“ฆ ํ•„์ˆ˜ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์„ค์น˜

๋จผ์ € ํ„ฐ๋ฏธ๋„์„ ์—ด๊ณ  ๋‹ค์Œ ๋ช…๋ น์–ด๋“ค์„ ์ž…๋ ฅํ•ด์ค˜:

pip install openai
pip install requests
pip install beautifulsoup4
pip install selenium
pip install python-dotenv
pip install schedule

๊ฐ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ํ•˜๋Š” ์ผ์„ ๊ฐ„๋‹จํžˆ ์„ค๋ช…ํ•˜๋ฉด:

openai: OpenAI API์™€ ํ†ต์‹ ํ•˜๊ธฐ ์œ„ํ•œ ๊ณต์‹ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
requests: HTTP ์š”์ฒญ์„ ๋ณด๋‚ด์„œ ์›นํŽ˜์ด์ง€๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
beautifulsoup4: HTML์„ ํŒŒ์‹ฑํ•˜๊ณ  ์›ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ถ”์ถœํ•˜๋Š” ๋„๊ตฌ
selenium: ๋™์  ์›นํŽ˜์ด์ง€๋ฅผ ํฌ๋กค๋งํ•  ๋•Œ ํ•„์š”ํ•œ ๋ธŒ๋ผ์šฐ์ € ์ž๋™ํ™” ๋„๊ตฌ
python-dotenv: API ํ‚ค ๊ฐ™์€ ๋ฏผ๊ฐํ•œ ์ •๋ณด๋ฅผ ์•ˆ์ „ํ•˜๊ฒŒ ๊ด€๋ฆฌ
schedule: ์ž๋™ํ™” ์Šค์ผ€์ค„๋ง์„ ์œ„ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
๐Ÿ”‘ OpenAI API ํ‚ค ๋ฐœ๊ธ‰๋ฐ›๊ธฐ OpenAI API๋ฅผ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ๋จผ์ € API ํ‚ค๊ฐ€ ํ•„์š”ํ•ด. ๋‹ค์Œ ๋‹จ๊ณ„๋ฅผ ๋”ฐ๋ผํ•ด๋ด:

1๏ธโƒฃ OpenAI ์›น์‚ฌ์ดํŠธ(platform.openai.com)์— ์ ‘์†
2๏ธโƒฃ ๊ณ„์ • ์ƒ์„ฑ ๋˜๋Š” ๋กœ๊ทธ์ธ
3๏ธโƒฃ API Keys ๋ฉ”๋‰ด๋กœ ์ด๋™
4๏ธโƒฃ "Create new secret key" ๋ฒ„ํŠผ ํด๋ฆญ
5๏ธโƒฃ ์ƒ์„ฑ๋œ ํ‚ค๋ฅผ ์•ˆ์ „ํ•œ ๊ณณ์— ๋ณต์‚ฌํ•ด์„œ ๋ณด๊ด€

โš ๏ธ ์ฃผ์˜: API ํ‚ค๋Š” ์ ˆ๋Œ€ ๊ณต๊ฐœ ์ €์žฅ์†Œ์— ์˜ฌ๋ฆฌ๋ฉด ์•ˆ ๋ผ! ๋ˆ„๊ตฐ๊ฐ€ ์•…์šฉํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ .

API ํ‚ค๋ฅผ ๋ฐ›์•˜๋‹ค๋ฉด, ํ”„๋กœ์ ํŠธ ๋ฃจํŠธ ๋””๋ ‰ํ† ๋ฆฌ์— .env ํŒŒ์ผ์„ ๋งŒ๋“ค์–ด์„œ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ €์žฅํ•ด์ค˜:

OPENAI_API_KEY=your-api-key-here
NEWS_API_KEY=your-news-api-key-here

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์ฝ”๋“œ์—์„œ ์ง์ ‘ ํ‚ค๋ฅผ ๋…ธ์ถœํ•˜์ง€ ์•Š๊ณ ๋„ ์•ˆ์ „ํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ˜Š

๐Ÿ•ท๏ธ ์›น ํฌ๋กค๋Ÿฌ ๊ตฌ์ถ•ํ•˜๊ธฐ

์ž, ์ด์ œ ๋‰ด์Šค๋ฅผ ์ˆ˜์ง‘ํ•˜๋Š” ํฌ๋กค๋Ÿฌ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ ์ฐจ๋ก€์•ผ! ํฌ๋กค๋Ÿฌ๋Š” ์šฐ๋ฆฌ ๋ด‡์˜ ๋ˆˆ๊ณผ ๊ท€ ์—ญํ• ์„ ํ•˜๋Š” ์ค‘์š”ํ•œ ๋ถ€๋ถ„์ด์ง€. ์›น์‚ฌ์ดํŠธ๋งˆ๋‹ค ๊ตฌ์กฐ๊ฐ€ ๋‹ค๋ฅด๊ธฐ ๋•Œ๋ฌธ์—, ์œ ์—ฐํ•˜๊ฒŒ ๋Œ€์‘ํ•  ์ˆ˜ ์žˆ๋Š” ํฌ๋กค๋Ÿฌ๋ฅผ ๋งŒ๋“œ๋Š” ๊ฒŒ ํ•ต์‹ฌ์ด์•ผ. ๐ŸŽฏ

ํฌ๋กค๋ง ๋ฐฉ์‹์€ ํฌ๊ฒŒ ๋‘ ๊ฐ€์ง€๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ์–ด:

๐Ÿ”น ์ •์  ํฌ๋กค๋ง vs ๋™์  ํฌ๋กค๋ง ์ •์  ํฌ๋กค๋ง: HTML์ด ์„œ๋ฒ„์—์„œ ์™„์„ฑ๋˜์–ด ์˜ค๋Š” ๊ฒฝ์šฐ. requests + BeautifulSoup ์กฐํ•ฉ์œผ๋กœ ์ถฉ๋ถ„ํ•ด. ๋น ๋ฅด๊ณ  ๊ฐ€๋ณ์ง€๋งŒ, JavaScript๋กœ ๋ Œ๋”๋ง๋˜๋Š” ์ฝ˜ํ…์ธ ๋Š” ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์—†์–ด.

๋™์  ํฌ๋กค๋ง: JavaScript๋กœ ์ฝ˜ํ…์ธ ๊ฐ€ ๋™์ ์œผ๋กœ ์ƒ์„ฑ๋˜๋Š” ๊ฒฝ์šฐ. Selenium์ด๋‚˜ Playwright ๊ฐ™์€ ๋ธŒ๋ผ์šฐ์ € ์ž๋™ํ™” ๋„๊ตฌ๊ฐ€ ํ•„์š”ํ•ด. ๋А๋ฆฌ์ง€๋งŒ ๋ชจ๋“  ์ฝ˜ํ…์ธ ๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ์–ด.

์šฐ๋ฆฌ๋Š” ๋‘ ๊ฐ€์ง€ ๋ฐฉ์‹์„ ๋ชจ๋‘ ๊ตฌํ˜„ํ•ด๋ณผ ๊ฑฐ์•ผ. ๋จผ์ € ๊ฐ„๋‹จํ•œ ์ •์  ํฌ๋กค๋ง๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด๋ณด์ž! ๐Ÿš€

๐Ÿ“„ ์ •์  ํฌ๋กค๋ง ๊ตฌํ˜„

import requests
from bs4 import BeautifulSoup
from datetime import datetime
import time

class NewsStaticCrawler:
    def __init__(self, base_url):
        self.base_url = base_url
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
    
    def fetch_page(self, url):
        """์›นํŽ˜์ด์ง€๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ๋ฉ”์„œ๋“œ"""
        try:
            response = requests.get(url, headers=self.headers, timeout=10)
            response.raise_for_status()
            return response.text
        except requests.RequestException as e:
            print(f"ํŽ˜์ด์ง€ ์š”์ฒญ ์‹คํŒจ: {e}")
            return None
    
    def parse_news_list(self, html):
        """๋‰ด์Šค ๋ชฉ๋ก์„ ํŒŒ์‹ฑํ•˜๋Š” ๋ฉ”์„œ๋“œ"""
        soup = BeautifulSoup(html, 'html.parser')
        news_items = []
        
        # ์˜ˆ์‹œ: ๋„ค์ด๋ฒ„ ๋‰ด์Šค ๊ตฌ์กฐ (์‹ค์ œ๋กœ๋Š” ํƒ€๊ฒŸ ์‚ฌ์ดํŠธ์— ๋งž๊ฒŒ ์ˆ˜์ • ํ•„์š”)
        articles = soup.select('.news_area')
        
        for article in articles:
            try:
                title_elem = article.select_one('.news_tit')
                title = title_elem.text.strip() if title_elem else "์ œ๋ชฉ ์—†์Œ"
                link = title_elem['href'] if title_elem else ""
                
                summary_elem = article.select_one('.news_dsc')
                summary = summary_elem.text.strip() if summary_elem else ""
                
                press_elem = article.select_one('.info.press')
                press = press_elem.text.strip() if press_elem else "์ถœ์ฒ˜ ๋ฏธ์ƒ"
                
                news_items.append({
                    'title': title,
                    'link': link,
                    'summary': summary,
                    'press': press,
                    'crawled_at': datetime.now().isoformat()
                })
            except Exception as e:
                print(f"๊ธฐ์‚ฌ ํŒŒ์‹ฑ ์ค‘ ์˜ค๋ฅ˜: {e}")
                continue
        
        return news_items
    
    def get_article_content(self, url):
        """๊ฐœ๋ณ„ ๊ธฐ์‚ฌ์˜ ๋ณธ๋ฌธ์„ ๊ฐ€์ ธ์˜ค๋Š” ๋ฉ”์„œ๋“œ"""
        html = self.fetch_page(url)
        if not html:
            return None
        
        soup = BeautifulSoup(html, 'html.parser')
        
        # ๋ณธ๋ฌธ ์ถ”์ถœ (์‚ฌ์ดํŠธ๋งˆ๋‹ค ๋‹ค๋ฆ„)
        content_elem = soup.select_one('#articleBodyContents')
        if content_elem:
            # ๋ถˆํ•„์š”ํ•œ ํƒœ๊ทธ ์ œ๊ฑฐ
            for tag in content_elem(['script', 'style', 'iframe']):
                tag.decompose()
            return content_elem.get_text(strip=True)
        
        return None
    
    def crawl_news(self, max_articles=10):
        """๋‰ด์Šค๋ฅผ ํฌ๋กค๋งํ•˜๋Š” ๋ฉ”์ธ ๋ฉ”์„œ๋“œ"""
        print(f"๐Ÿ•ท๏ธ ํฌ๋กค๋ง ์‹œ์ž‘: {self.base_url}")
        
        html = self.fetch_page(self.base_url)
        if not html:
            return []
        
        news_list = self.parse_news_list(html)
        detailed_news = []
        
        for i, news in enumerate(news_list[:max_articles]):
            print(f"๐Ÿ“ฐ {i+1}/{max_articles}: {news['title'][:50]}...")
            
            # ๋ณธ๋ฌธ ๊ฐ€์ ธ์˜ค๊ธฐ
            content = self.get_article_content(news['link'])
            if content:
                news['content'] = content
                detailed_news.append(news)
            
            # ์„œ๋ฒ„ ๋ถ€ํ•˜ ๋ฐฉ์ง€๋ฅผ ์œ„ํ•œ ๋”œ๋ ˆ์ด
            time.sleep(1)
        
        print(f"โœ… ํฌ๋กค๋ง ์™„๋ฃŒ: {len(detailed_news)}๊ฐœ ๊ธฐ์‚ฌ ์ˆ˜์ง‘")
        return detailed_news

์ด ์ฝ”๋“œ๋Š” ๊ธฐ๋ณธ์ ์ธ ์ •์  ํฌ๋กค๋Ÿฌ์˜ ๊ตฌ์กฐ์•ผ. ์‹ค์ œ๋กœ ์‚ฌ์šฉํ•  ๋•Œ๋Š” ํƒ€๊ฒŸ ์›น์‚ฌ์ดํŠธ์˜ HTML ๊ตฌ์กฐ๋ฅผ ๋ถ„์„ํ•ด์„œ ์…€๋ ‰ํ„ฐ๋ฅผ ์ˆ˜์ •ํ•ด์•ผ ํ•ด. ํฌ๋กฌ ๊ฐœ๋ฐœ์ž ๋„๊ตฌ(F12)๋ฅผ ์—ด์–ด์„œ ์š”์†Œ๋ฅผ ๊ฒ€์‚ฌํ•˜๋ฉด ์‰ฝ๊ฒŒ ์ฐพ์„ ์ˆ˜ ์žˆ์–ด! ๐Ÿ”

๐Ÿ’ก ํฌ๋กค๋ง ํŒ โ€ข robots.txt ํ™•์ธ: ์›น์‚ฌ์ดํŠธ์˜ /robots.txt ํŒŒ์ผ์„ ํ™•์ธํ•ด์„œ ํฌ๋กค๋ง์ด ํ—ˆ์šฉ๋˜๋Š”์ง€ ์ฒดํฌํ•ด์•ผ ํ•ด
โ€ข User-Agent ์„ค์ •: ๋ด‡์œผ๋กœ ์ธ์‹๋˜์ง€ ์•Š๋„๋ก ๋ธŒ๋ผ์šฐ์ €์ฒ˜๋Ÿผ ๋ณด์ด๊ฒŒ ๋งŒ๋“ค์–ด
โ€ข ์š”์ฒญ ๊ฐ„๊ฒฉ ์กฐ์ ˆ: ๋„ˆ๋ฌด ๋น ๋ฅด๊ฒŒ ์š”์ฒญํ•˜๋ฉด IP๊ฐ€ ์ฐจ๋‹จ๋  ์ˆ˜ ์žˆ์œผ๋‹ˆ ์ ์ ˆํ•œ ๋”œ๋ ˆ์ด๋ฅผ ๋„ฃ์–ด์ค˜
โ€ข ์—๋Ÿฌ ์ฒ˜๋ฆฌ: ๋„คํŠธ์›Œํฌ ์˜ค๋ฅ˜๋‚˜ ํŒŒ์‹ฑ ์˜ค๋ฅ˜์— ๋Œ€๋น„ํ•œ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ๊ฐ€ ํ•„์ˆ˜์•ผ

๐ŸŒ ๋™์  ํฌ๋กค๋ง ๊ตฌํ˜„

์ด์ œ JavaScript๋กœ ๋ Œ๋”๋ง๋˜๋Š” ํŽ˜์ด์ง€๋ฅผ ํฌ๋กค๋งํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์•Œ์•„๋ณด์ž. Selenium์„ ์‚ฌ์šฉํ•˜๋ฉด ์‹ค์ œ ๋ธŒ๋ผ์šฐ์ €๋ฅผ ์ œ์–ดํ•  ์ˆ˜ ์žˆ์–ด์„œ ๋™์  ์ฝ˜ํ…์ธ ๋„ ๋ฌธ์ œ์—†์ด ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ์–ด! ๐ŸŽญ

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
import time

class NewsDynamicCrawler:
    def __init__(self):
        self.driver = None
        self.setup_driver()
    
    def setup_driver(self):
        """Selenium ๋“œ๋ผ์ด๋ฒ„ ์„ค์ •"""
        chrome_options = Options()
        chrome_options.add_argument('--headless')  # ๋ธŒ๋ผ์šฐ์ € ์ฐฝ ์ˆจ๊ธฐ๊ธฐ
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        chrome_options.add_argument('--disable-gpu')
        chrome_options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64)')
        
        self.driver = webdriver.Chrome(options=chrome_options)
        self.driver.implicitly_wait(10)
    
    def scroll_to_load(self, scroll_pause_time=2):
        """๋ฌดํ•œ ์Šคํฌ๋กค ํŽ˜์ด์ง€๋ฅผ ์œ„ํ•œ ์Šคํฌ๋กค ํ•จ์ˆ˜"""
        last_height = self.driver.execute_script("return document.body.scrollHeight")
        
        while True:
            # ํŽ˜์ด์ง€ ๋๊นŒ์ง€ ์Šคํฌ๋กค
            self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
            time.sleep(scroll_pause_time)
            
            # ์ƒˆ๋กœ์šด ๋†’์ด ๊ณ„์‚ฐ
            new_height = self.driver.execute_script("return document.body.scrollHeight")
            if new_height == last_height:
                break
            last_height = new_height
    
    def crawl_dynamic_news(self, url, max_articles=10):
        """๋™์  ํŽ˜์ด์ง€ ํฌ๋กค๋ง"""
        try:
            print(f"๐ŸŒ ๋™์  ํฌ๋กค๋ง ์‹œ์ž‘: {url}")
            self.driver.get(url)
            
            # ํŽ˜์ด์ง€ ๋กœ๋”ฉ ๋Œ€๊ธฐ
            WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.CLASS_NAME, "news-item"))
            )
            
            # ํ•„์š”์‹œ ์Šคํฌ๋กค
            self.scroll_to_load()
            
            # ๋‰ด์Šค ์•„์ดํ…œ ์ถ”์ถœ
            news_elements = self.driver.find_elements(By.CLASS_NAME, "news-item")
            news_list = []
            
            for i, element in enumerate(news_elements[:max_articles]):
                try:
                    title = element.find_element(By.CLASS_NAME, "title").text
                    link = element.find_element(By.TAG_NAME, "a").get_attribute("href")
                    summary = element.find_element(By.CLASS_NAME, "summary").text
                    
                    news_list.append({
                        'title': title,
                        'link': link,
                        'summary': summary,
                        'crawled_at': datetime.now().isoformat()
                    })
                    
                    print(f"๐Ÿ“ฐ {i+1}/{max_articles}: {title[:50]}...")
                except Exception as e:
                    print(f"์š”์†Œ ์ถ”์ถœ ์˜ค๋ฅ˜: {e}")
                    continue
            
            print(f"โœ… ๋™์  ํฌ๋กค๋ง ์™„๋ฃŒ: {len(news_list)}๊ฐœ ๊ธฐ์‚ฌ")
            return news_list
            
        except Exception as e:
            print(f"ํฌ๋กค๋ง ์ค‘ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {e}")
            return []
        finally:
            if self.driver:
                self.driver.quit()
    
    def wait_for_element(self, by, value, timeout=10):
        """ํŠน์ • ์š”์†Œ๊ฐ€ ๋กœ๋“œ๋  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ"""
        try:
            element = WebDriverWait(self.driver, timeout).until(
                EC.presence_of_element_located((by, value))
            )
            return element
        except Exception as e:
            print(f"์š”์†Œ ๋Œ€๊ธฐ ์‹œ๊ฐ„ ์ดˆ๊ณผ: {e}")
            return None

Selenium์€ ๊ฐ•๋ ฅํ•˜์ง€๋งŒ ๋ฆฌ์†Œ์Šค๋ฅผ ๋งŽ์ด ์‚ฌ์šฉํ•ด. ๊ทธ๋ž˜์„œ ๊ฐ€๋Šฅํ•˜๋ฉด ์ •์  ํฌ๋กค๋ง์„ ์šฐ์„  ์‹œ๋„ํ•˜๊ณ , ์ •๋ง ํ•„์š”ํ•œ ๊ฒฝ์šฐ์—๋งŒ Selenium์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒŒ ์ข‹์•„. ๋˜ํ•œ headless ๋ชจ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ธŒ๋ผ์šฐ์ € ์ฐฝ์ด ๋œจ์ง€ ์•Š์•„์„œ ์„œ๋ฒ„ ํ™˜๊ฒฝ์—์„œ๋„ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ’ป

๐Ÿค– OpenAI API ์—ฐ๋™ํ•˜๊ธฐ

๋“œ๋””์–ด AI์˜ ํž˜์„ ๋นŒ๋ฆด ์‹œ๊ฐ„์ด์•ผ! OpenAI์˜ GPT ๋ชจ๋ธ์„ ์‚ฌ์šฉํ•˜๋ฉด ์ˆ˜์ง‘ํ•œ ๋‰ด์Šค๋ฅผ ์ž์—ฐ์Šค๋Ÿฝ๊ณ  ์ •ํ™•ํ•˜๊ฒŒ ์š”์•ฝํ•  ์ˆ˜ ์žˆ์–ด. ์ด ๋ถ€๋ถ„์ด ๋ฐ”๋กœ ์šฐ๋ฆฌ ๋ด‡์˜ ๋‘๋‡Œ ์—ญํ• ์„ ํ•˜๋Š” ํ•ต์‹ฌ์ด์ง€! ๐Ÿง โœจ

OpenAI API๋Š” ์‚ฌ์šฉํ•˜๊ธฐ ์ •๋ง ๊ฐ„๋‹จํ•ด. ํ•˜์ง€๋งŒ ํšจ๊ณผ์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๋ ค๋ฉด ํ”„๋กฌํ”„ํŠธ ์—”์ง€๋‹ˆ์–ด๋ง์ด ์ค‘์š”ํ•ด. ์ข‹์€ ํ”„๋กฌํ”„ํŠธ๋ฅผ ์ž‘์„ฑํ•˜๋ฉด ํ›จ์”ฌ ๋” ๋‚˜์€ ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๊ฑฐ๋“ !

๐ŸŽฏ ํ”„๋กฌํ”„ํŠธ ์—”์ง€๋‹ˆ์–ด๋ง์˜ ํ•ต์‹ฌ ์›์น™ 1๏ธโƒฃ ๋ช…ํ™•์„ฑ: ์›ํ•˜๋Š” ๊ฒฐ๊ณผ๋ฅผ ๊ตฌ์ฒด์ ์œผ๋กœ ์„ค๋ช…ํ•ด
2๏ธโƒฃ ๋งฅ๋ฝ ์ œ๊ณต: AI์—๊ฒŒ ์ถฉ๋ถ„ํ•œ ๋ฐฐ๊ฒฝ ์ •๋ณด๋ฅผ ์ค˜
3๏ธโƒฃ ํ˜•์‹ ์ง€์ •: ์ถœ๋ ฅ ํ˜•์‹์„ ๋ช…ํ™•ํžˆ ์ •์˜ํ•ด
4๏ธโƒฃ ์˜ˆ์‹œ ์ œ๊ณต: Few-shot learning์œผ๋กœ ํ’ˆ์งˆ ํ–ฅ์ƒ
5๏ธโƒฃ ์ œ์•ฝ ์กฐ๊ฑด: ๊ธ€์ž ์ˆ˜, ํ†ค์•ค๋งค๋„ˆ ๋“ฑ์„ ๋ช…์‹œํ•ด
import openai
from dotenv import load_dotenv
import os
import json

# ํ™˜๊ฒฝ ๋ณ€์ˆ˜ ๋กœ๋“œ
load_dotenv()
openai.api_key = os.getenv('OPENAI_API_KEY')

class NewsAISummarizer:
    def __init__(self, model="gpt-4o-mini"):
        self.model = model
        self.max_tokens = 500
        self.temperature = 0.7
    
    def create_summary_prompt(self, article):
        """์š”์•ฝ์„ ์œ„ํ•œ ํ”„๋กฌํ”„ํŠธ ์ƒ์„ฑ"""
        prompt = f"""๋‹น์‹ ์€ ์ „๋ฌธ ๋‰ด์Šค ์—๋””ํ„ฐ์ž…๋‹ˆ๋‹ค. ๋‹ค์Œ ๋‰ด์Šค ๊ธฐ์‚ฌ๋ฅผ ์ฝ๊ณ  ํ•ต์‹ฌ ๋‚ด์šฉ์„ ์š”์•ฝํ•ด์ฃผ์„ธ์š”.

์š”์•ฝ ๊ฐ€์ด๋“œ๋ผ์ธ:
- 3-5๋ฌธ์žฅ์œผ๋กœ ๊ฐ„๊ฒฐํ•˜๊ฒŒ ์ž‘์„ฑ
- 5W1H(๋ˆ„๊ฐ€, ์–ธ์ œ, ์–ด๋””์„œ, ๋ฌด์—‡์„, ์™œ, ์–ด๋–ป๊ฒŒ)๋ฅผ ํฌํ•จ
- ๊ฐ๊ด€์ ์ด๊ณ  ์ค‘๋ฆฝ์ ์ธ ํ†ค ์œ ์ง€
- ์ค‘์š”ํ•œ ์ˆ˜์น˜๋‚˜ ๋‚ ์งœ๋Š” ์ •ํ™•ํžˆ ํฌํ•จ
- ๋ถˆํ•„์š”ํ•œ ์ˆ˜์‹์–ด ์ œ๊ฑฐ

๊ธฐ์‚ฌ ์ œ๋ชฉ: {article['title']}
๊ธฐ์‚ฌ ๋ณธ๋ฌธ:
{article['content'][:3000]}

์š”์•ฝ:"""
        return prompt
    
    def summarize_article(self, article):
        """๋‹จ์ผ ๊ธฐ์‚ฌ ์š”์•ฝ"""
        try:
            prompt = self.create_summary_prompt(article)
            
            response = openai.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "๋‹น์‹ ์€ ๋‰ด์Šค ์š”์•ฝ ์ „๋ฌธ๊ฐ€์ž…๋‹ˆ๋‹ค."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=self.max_tokens,
                temperature=self.temperature
            )
            
            summary = response.choices[0].message.content.strip()
            
            return {
                'original_title': article['title'],
                'original_link': article['link'],
                'summary': summary,
                'press': article.get('press', ''),
                'tokens_used': response.usage.total_tokens,
                'summarized_at': datetime.now().isoformat()
            }
            
        except Exception as e:
            print(f"์š”์•ฝ ์ค‘ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {e}")
            return None
    
    def batch_summarize(self, articles, delay=1):
        """์—ฌ๋Ÿฌ ๊ธฐ์‚ฌ ์ผ๊ด„ ์š”์•ฝ"""
        summaries = []
        total_tokens = 0
        
        print(f"๐Ÿค– AI ์š”์•ฝ ์‹œ์ž‘: {len(articles)}๊ฐœ ๊ธฐ์‚ฌ")
        
        for i, article in enumerate(articles):
            print(f"๐Ÿ“ ์š”์•ฝ ์ค‘ ({i+1}/{len(articles)}): {article['title'][:40]}...")
            
            summary = self.summarize_article(article)
            if summary:
                summaries.append(summary)
                total_tokens += summary['tokens_used']
            
            # API ๋ ˆ์ดํŠธ ๋ฆฌ๋ฐ‹ ๋ฐฉ์ง€
            time.sleep(delay)
        
        print(f"โœ… ์š”์•ฝ ์™„๋ฃŒ: {len(summaries)}๊ฐœ / ์ด ํ† ํฐ: {total_tokens}")
        return summaries, total_tokens
    
    def create_digest(self, summaries, topic="์˜ค๋Š˜์˜ ๋‰ด์Šค"):
        """์—ฌ๋Ÿฌ ์š”์•ฝ์„ ํ•˜๋‚˜์˜ ๋‹ค์ด์ œ์ŠคํŠธ๋กœ ํ†ตํ•ฉ"""
        summaries_text = "\n\n".join([
            f"{i+1}. {s['original_title']}\n{s['summary']}"
            for i, s in enumerate(summaries)
        ])
        
        prompt = f"""๋‹ค์Œ์€ ์˜ค๋Š˜์˜ ์ฃผ์š” ๋‰ด์Šค ์š”์•ฝ๋“ค์ž…๋‹ˆ๋‹ค. ์ด๋ฅผ ๋ฐ”ํƒ•์œผ๋กœ ์ „์ฒด์ ์ธ ๋‰ด์Šค ๋‹ค์ด์ œ์ŠคํŠธ๋ฅผ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.

{summaries_text}

๋‹ค์ด์ œ์ŠคํŠธ ์ž‘์„ฑ ๊ฐ€์ด๋“œ:
- ์ „์ฒด์ ์ธ ํ๋ฆ„๊ณผ ๋งฅ๋ฝ์„ ํŒŒ์•…
- ์—ฐ๊ด€๋œ ๋‰ด์Šค๋“ค์„ ๊ทธ๋ฃนํ™”
- ์ค‘์š”๋„ ์ˆœ์œผ๋กœ ์žฌ๋ฐฐ์น˜
- ๊ฐ„๊ฒฐํ•˜๊ณ  ์ฝ๊ธฐ ์‰ฝ๊ฒŒ ์ž‘์„ฑ

๋‹ค์ด์ œ์ŠคํŠธ:"""
        
        try:
            response = openai.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": "๋‹น์‹ ์€ ๋‰ด์Šค ํ๋ ˆ์ดํ„ฐ์ž…๋‹ˆ๋‹ค."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=1000,
                temperature=0.7
            )
            
            return response.choices[0].message.content.strip()
        except Exception as e:
            print(f"๋‹ค์ด์ œ์ŠคํŠธ ์ƒ์„ฑ ์˜ค๋ฅ˜: {e}")
            return None

์ด ์ฝ”๋“œ๋Š” OpenAI API๋ฅผ ํ™œ์šฉํ•œ ๋‰ด์Šค ์š”์•ฝ ์‹œ์Šคํ…œ์˜ ํ•ต์‹ฌ์ด์•ผ. gpt-4o-mini ๋ชจ๋ธ์„ ์‚ฌ์šฉํ•˜๋ฉด ๋น„์šฉ ๋Œ€๋น„ ์„ฑ๋Šฅ์ด ์ข‹์•„์„œ ์‹ค์šฉ์ ์ด์•ผ. ๋ฌผ๋ก  ๋” ๋†’์€ ํ’ˆ์งˆ์ด ํ•„์š”ํ•˜๋ฉด gpt-4๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜๋„ ์žˆ์–ด! ๐Ÿ’ฐ

๐Ÿ’ก API ๋น„์šฉ ์ตœ์ ํ™” ํŒ โ€ข ํ† ํฐ ๊ด€๋ฆฌ: ์ž…๋ ฅ ํ…์ŠคํŠธ๋ฅผ ์ ์ ˆํžˆ ์ž๋ฅด๊ณ , max_tokens๋ฅผ ์กฐ์ ˆํ•ด์„œ ๋น„์šฉ์„ ์ ˆ๊ฐํ•ด
โ€ข ์บ์‹ฑ ํ™œ์šฉ: ๊ฐ™์€ ๊ธฐ์‚ฌ๋ฅผ ์ค‘๋ณต ์š”์•ฝํ•˜์ง€ ์•Š๋„๋ก ์บ์‹œ๋ฅผ ๊ตฌํ˜„ํ•ด
โ€ข ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ: ์—ฌ๋Ÿฌ ์š”์•ฝ์„ ํ•œ ๋ฒˆ์— ์š”์ฒญํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ๊ฐœ๋ณ„ ์ฒ˜๋ฆฌ๊ฐ€ ๋” ํšจ์œจ์ ์ผ ์ˆ˜ ์žˆ์–ด
โ€ข ๋ชจ๋ธ ์„ ํƒ: ์ž‘์—…์— ๋”ฐ๋ผ ์ ์ ˆํ•œ ๋ชจ๋ธ์„ ์„ ํƒํ•ด. ๊ฐ„๋‹จํ•œ ์š”์•ฝ์€ mini ๋ชจ๋ธ๋กœ๋„ ์ถฉ๋ถ„ํ•ด

๐ŸŽจ ๊ณ ๊ธ‰ ํ”„๋กฌํ”„ํŠธ ๊ธฐ๋ฒ•

๋” ๋‚˜์€ ์š”์•ฝ ๊ฒฐ๊ณผ๋ฅผ ์–ป๊ธฐ ์œ„ํ•œ ๊ณ ๊ธ‰ ํ”„๋กฌํ”„ํŠธ ๊ธฐ๋ฒ•๋“ค์„ ์•Œ์•„๋ณด์ž! ์ด๋Ÿฐ ํ…Œํฌ๋‹‰๋“ค์„ ์‚ฌ์šฉํ•˜๋ฉด AI์˜ ์„ฑ๋Šฅ์„ ๊ทน๋Œ€ํ™”ํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿš€

class AdvancedPromptTemplates:
    @staticmethod
    def chain_of_thought_summary(article):
        """์‚ฌ๊ณ ์˜ ์—ฐ์‡„(Chain of Thought) ๊ธฐ๋ฒ•"""
        return f"""๋‹ค์Œ ๋‰ด์Šค ๊ธฐ์‚ฌ๋ฅผ ๋‹จ๊ณ„์ ์œผ๋กœ ๋ถ„์„ํ•˜๊ณ  ์š”์•ฝํ•ด์ฃผ์„ธ์š”.

๊ธฐ์‚ฌ: {article['title']}
{article['content'][:2000]}

๋ถ„์„ ๋‹จ๊ณ„:
1. ์ฃผ์š” ์‚ฌ๊ฑด/์ด์Šˆ ํŒŒ์•…
2. ๊ด€๋ จ ์ธ๋ฌผ/๊ธฐ๊ด€ ์‹๋ณ„
3. ์‹œ๊ฐ„์  ๋ฐฐ๊ฒฝ ํ™•์ธ
4. ์˜ํ–ฅ๊ณผ ์˜๋ฏธ ๋ถ„์„
5. ํ•ต์‹ฌ ๋ฉ”์‹œ์ง€ ์ถ”์ถœ

๊ฐ ๋‹จ๊ณ„๋ฅผ ๊ฑฐ์ณ ์ตœ์ข… ์š”์•ฝ์„ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”."""
    
    @staticmethod
    def few_shot_summary(article):
        """Few-shot Learning ๊ธฐ๋ฒ•"""
        return f"""๋‹ค์Œ์€ ๋‰ด์Šค ์š”์•ฝ์˜ ์ข‹์€ ์˜ˆ์‹œ์ž…๋‹ˆ๋‹ค:

์˜ˆ์‹œ 1:
์›๋ฌธ: "์ •๋ถ€๊ฐ€ ๋‚ด๋…„๋„ ์ตœ์ €์ž„๊ธˆ์„ ์‹œ๊ฐ„๋‹น 9,860์›์œผ๋กœ ๊ฒฐ์ •ํ–ˆ๋‹ค..."
์š”์•ฝ: ์ •๋ถ€๋Š” 2024๋…„ ์ตœ์ €์ž„๊ธˆ์„ ์‹œ๊ฐ„๋‹น 9,860์›์œผ๋กœ ํ™•์ •ํ–ˆ๋‹ค. ์ด๋Š” ์˜ฌํ•ด ๋Œ€๋น„ 2.5% ์ธ์ƒ๋œ ๊ธˆ์•ก์œผ๋กœ, ์•ฝ 330๋งŒ ๋ช…์˜ ๊ทผ๋กœ์ž์—๊ฒŒ ์˜ํ–ฅ์„ ๋ฏธ์น  ์ „๋ง์ด๋‹ค.

์˜ˆ์‹œ 2:
์›๋ฌธ: "์‚ผ์„ฑ์ „์ž๊ฐ€ ์ฐจ์„ธ๋Œ€ ๋ฐ˜๋„์ฒด ๊ธฐ์ˆ  ๊ฐœ๋ฐœ์— ์„ฑ๊ณตํ–ˆ๋‹ค๊ณ  ๋ฐœํ‘œํ–ˆ๋‹ค..."
์š”์•ฝ: ์‚ผ์„ฑ์ „์ž๊ฐ€ 3๋‚˜๋…ธ ๊ณต์ • ๊ธฐ์ˆ  ๊ฐœ๋ฐœ์— ์„ฑ๊ณตํ–ˆ๋‹ค. ์ด ๊ธฐ์ˆ ์€ ๊ธฐ์กด ๋Œ€๋น„ ์ „๋ ฅ ์†Œ๋น„๋ฅผ 30% ์ค„์ด๊ณ  ์„ฑ๋Šฅ์€ 15% ํ–ฅ์ƒ์‹œํ‚ฌ ์ˆ˜ ์žˆ์–ด, ๊ธ€๋กœ๋ฒŒ ๋ฐ˜๋„์ฒด ์‹œ์žฅ์—์„œ ๊ฒฝ์Ÿ๋ ฅ์„ ๋†’์ผ ๊ฒƒ์œผ๋กœ ๊ธฐ๋Œ€๋œ๋‹ค.

์ด์ œ ๋‹ค์Œ ๊ธฐ์‚ฌ๋ฅผ ์œ„์™€ ๊ฐ™์€ ์Šคํƒ€์ผ๋กœ ์š”์•ฝํ•ด์ฃผ์„ธ์š”:
{article['title']}
{article['content'][:2000]}"""
    
    @staticmethod
    def structured_summary(article):
        """๊ตฌ์กฐํ™”๋œ ์ถœ๋ ฅ ์š”์ฒญ"""
        return f"""๋‹ค์Œ ๋‰ด์Šค๋ฅผ JSON ํ˜•์‹์œผ๋กœ ๊ตฌ์กฐํ™”ํ•˜์—ฌ ์š”์•ฝํ•ด์ฃผ์„ธ์š”.

๊ธฐ์‚ฌ: {article['content'][:2000]}

์ถœ๋ ฅ ํ˜•์‹:
{{
    "headline": "ํ•œ ์ค„ ํ—ค๋“œ๋ผ์ธ",
    "summary": "3-4๋ฌธ์žฅ ์š”์•ฝ",
    "key_points": ["ํ•ต์‹ฌ ํฌ์ธํŠธ 1", "ํ•ต์‹ฌ ํฌ์ธํŠธ 2", "ํ•ต์‹ฌ ํฌ์ธํŠธ 3"],
    "entities": {{
        "people": ["๊ด€๋ จ ์ธ๋ฌผ"],
        "organizations": ["๊ด€๋ จ ๊ธฐ๊ด€"],
        "locations": ["๊ด€๋ จ ์žฅ์†Œ"]
    }},
    "category": "์นดํ…Œ๊ณ ๋ฆฌ",
    "sentiment": "๊ธ์ •/์ค‘๋ฆฝ/๋ถ€์ •"
}}"""
    
    @staticmethod
    def audience_targeted_summary(article, audience="์ผ๋ฐ˜์ธ"):
        """ํƒ€๊ฒŸ ๋…์ž ๋งž์ถค ์š”์•ฝ"""
        audience_styles = {
            "์ผ๋ฐ˜์ธ": "์‰ฝ๊ณ  ๊ฐ„๋‹จํ•œ ์šฉ์–ด๋กœ ์„ค๋ช…",
            "์ „๋ฌธ๊ฐ€": "์ „๋ฌธ ์šฉ์–ด์™€ ์ƒ์„ธํ•œ ๋ถ„์„ ํฌํ•จ",
            "ํ•™์ƒ": "๊ต์œก์  ๊ด€์ ์—์„œ ์ดํ•ดํ•˜๊ธฐ ์‰ฝ๊ฒŒ",
            "ํˆฌ์ž์ž": "๊ฒฝ์ œ์  ์˜ํ–ฅ๊ณผ ์‹œ์žฅ ์ „๋ง ์ค‘์‹ฌ"
        }
        
        style = audience_styles.get(audience, audience_styles["์ผ๋ฐ˜์ธ"])
        
        return f"""๋‹ค์Œ ๋‰ด์Šค๋ฅผ {audience}์„ ์œ„ํ•ด ์š”์•ฝํ•ด์ฃผ์„ธ์š”.
์Šคํƒ€์ผ: {style}

๊ธฐ์‚ฌ: {article['content'][:2000]}

์š”์•ฝ:"""

์ด๋Ÿฐ ๊ณ ๊ธ‰ ๊ธฐ๋ฒ•๋“ค์„ ์‚ฌ์šฉํ•˜๋ฉด ๋‹จ์ˆœํ•œ ์š”์•ฝ์„ ๋„˜์–ด์„œ ๋” ํ’๋ถ€ํ•˜๊ณ  ์œ ์šฉํ•œ ์ •๋ณด๋ฅผ ์ œ๊ณตํ•  ์ˆ˜ ์žˆ์–ด. ํŠนํžˆ ๊ตฌ์กฐํ™”๋œ ์ถœ๋ ฅ์€ ๋‚˜์ค‘์— ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์— ์ €์žฅํ•˜๊ฑฐ๋‚˜ ๋‹ค๋ฅธ ์‹œ์Šคํ…œ๊ณผ ์—ฐ๋™ํ•  ๋•Œ ์ •๋ง ์œ ์šฉํ•ด! ๐Ÿ“Š

๐Ÿ”„ ์ž๋™ํ™” ์‹œ์Šคํ…œ ๊ตฌ์ถ•ํ•˜๊ธฐ

์ด์ œ ํฌ๋กค๋Ÿฌ์™€ AI ์š”์•ฝ๊ธฐ๋ฅผ ๋งŒ๋“ค์—ˆ์œผ๋‹ˆ, ์ด๊ฑธ ์ž๋™์œผ๋กœ ์‹คํ–‰๋˜๊ฒŒ ๋งŒ๋“ค์–ด์•ผ ํ•ด! ๋งค์ผ ์ •ํ•ด์ง„ ์‹œ๊ฐ„์— ์ž๋™์œผ๋กœ ๋‰ด์Šค๋ฅผ ์ˆ˜์ง‘ํ•˜๊ณ  ์š”์•ฝํ•˜๋Š” ์‹œ์Šคํ…œ์„ ๊ตฌ์ถ•ํ•ด๋ณด์ž. ์ด๊ฒŒ ๋ฐ”๋กœ ์ง„์งœ '๋ด‡'๋‹ค์šด ๋ชจ์Šต์ด์ง€! ๐Ÿค–โฐ

โš™๏ธ ์ž๋™ํ™” ์‹œ์Šคํ…œ์˜ ํ•ต์‹ฌ ์š”์†Œ ์Šค์ผ€์ค„๋ง: ์ •ํ•ด์ง„ ์‹œ๊ฐ„์— ์ž‘์—… ์‹คํ–‰
์—๋Ÿฌ ํ•ธ๋“ค๋ง: ์‹คํŒจํ•ด๋„ ๊ณ„์† ๋™์ž‘ํ•˜๋„๋ก
๋กœ๊น…: ๋ชจ๋“  ์ž‘์—… ๊ธฐ๋ก ๋‚จ๊ธฐ๊ธฐ
์•Œ๋ฆผ: ์ž‘์—… ์™„๋ฃŒ๋‚˜ ์˜ค๋ฅ˜ ๋ฐœ์ƒ ์‹œ ์•Œ๋ฆผ
๋ฐ์ดํ„ฐ ์ €์žฅ: ๊ฒฐ๊ณผ๋ฅผ ์•ˆ์ „ํ•˜๊ฒŒ ๋ณด๊ด€
import schedule
import time
import logging
from datetime import datetime
import json
import sqlite3
from pathlib import Path

# ๋กœ๊น… ์„ค์ •
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('news_bot.log'),
        logging.StreamHandler()
    ]
)

class NewsAutomationBot:
    def __init__(self, config_path='config.json'):
        self.config = self.load_config(config_path)
        self.crawler = None
        self.summarizer = None
        self.db_path = 'news_summaries.db'
        self.setup_database()
    
    def load_config(self, config_path):
        """์„ค์ • ํŒŒ์ผ ๋กœ๋“œ"""
        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            logging.warning("์„ค์ • ํŒŒ์ผ์ด ์—†์Šต๋‹ˆ๋‹ค. ๊ธฐ๋ณธ ์„ค์ •์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.")
            return self.get_default_config()
    
    def get_default_config(self):
        """๊ธฐ๋ณธ ์„ค์ •"""
        return {
            "news_sources": [
                {"name": "๋„ค์ด๋ฒ„๋‰ด์Šค", "url": "https://news.naver.com", "type": "static"},
                {"name": "๋‹ค์Œ๋‰ด์Šค", "url": "https://news.daum.net", "type": "static"}
            ],
            "schedule": {
                "times": ["09:00", "15:00", "21:00"],
                "max_articles": 10
            },
            "notification": {
                "enabled": True,
                "email": "your-email@example.com"
            }
        }
    
    def setup_database(self):
        """๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ดˆ๊ธฐํ™”"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS news_summaries (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                original_link TEXT,
                summary TEXT,
                press TEXT,
                category TEXT,
                crawled_at TEXT,
                summarized_at TEXT,
                tokens_used INTEGER
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS bot_logs (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp TEXT,
                status TEXT,
                articles_processed INTEGER,
                total_tokens INTEGER,
                error_message TEXT
            )
        ''')
        
        conn.commit()
        conn.close()
        logging.info("โœ… ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ดˆ๊ธฐํ™” ์™„๋ฃŒ")
    
    def save_summaries(self, summaries):
        """์š”์•ฝ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์— ์ €์žฅ"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        for summary in summaries:
            cursor.execute('''
                INSERT INTO news_summaries 
                (title, original_link, summary, press, summarized_at, tokens_used)
                VALUES (?, ?, ?, ?, ?, ?)
            ''', (
                summary['original_title'],
                summary['original_link'],
                summary['summary'],
                summary.get('press', ''),
                summary['summarized_at'],
                summary['tokens_used']
            ))
        
        conn.commit()
        conn.close()
        logging.info(f"๐Ÿ’พ {len(summaries)}๊ฐœ ์š”์•ฝ ์ €์žฅ ์™„๋ฃŒ")
    
    def log_execution(self, status, articles_count, tokens, error=None):
        """์‹คํ–‰ ๋กœ๊ทธ ์ €์žฅ"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO bot_logs 
            (timestamp, status, articles_processed, total_tokens, error_message)
            VALUES (?, ?, ?, ?, ?)
        ''', (
            datetime.now().isoformat(),
            status,
            articles_count,
            tokens,
            error
        ))
        
        conn.commit()
        conn.close()
    
    def run_news_cycle(self):
        """๋‰ด์Šค ์ˆ˜์ง‘ ๋ฐ ์š”์•ฝ ์‚ฌ์ดํด ์‹คํ–‰"""
        try:
            logging.info("๐Ÿš€ ๋‰ด์Šค ๋ด‡ ์‹คํ–‰ ์‹œ์ž‘")
            
            # ํฌ๋กค๋Ÿฌ ์ดˆ๊ธฐํ™”
            crawler = NewsStaticCrawler(self.config['news_sources'][0]['url'])
            summarizer = NewsAISummarizer()
            
            # ๋‰ด์Šค ์ˆ˜์ง‘
            articles = crawler.crawl_news(
                max_articles=self.config['schedule']['max_articles']
            )
            
            if not articles:
                logging.warning("โš ๏ธ ์ˆ˜์ง‘๋œ ๊ธฐ์‚ฌ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค")
                return
            
            # AI ์š”์•ฝ
            summaries, total_tokens = summarizer.batch_summarize(articles)
            
            # ๊ฒฐ๊ณผ ์ €์žฅ
            self.save_summaries(summaries)
            
            # ๋‹ค์ด์ œ์ŠคํŠธ ์ƒ์„ฑ
            digest = summarizer.create_digest(summaries)
            if digest:
                self.save_digest(digest)
            
            # ๋กœ๊ทธ ๊ธฐ๋ก
            self.log_execution('SUCCESS', len(summaries), total_tokens)
            
            # ์•Œ๋ฆผ ๋ฐœ์†ก
            if self.config['notification']['enabled']:
                self.send_notification(summaries, digest)
            
            logging.info(f"โœ… ๋‰ด์Šค ๋ด‡ ์‹คํ–‰ ์™„๋ฃŒ: {len(summaries)}๊ฐœ ์š”์•ฝ")
            
        except Exception as e:
            logging.error(f"โŒ ์‹คํ–‰ ์ค‘ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {e}")
            self.log_execution('ERROR', 0, 0, str(e))
    
    def save_digest(self, digest):
        """๋‹ค์ด์ œ์ŠคํŠธ๋ฅผ ํŒŒ์ผ๋กœ ์ €์žฅ"""
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filename = f"digest_{timestamp}.txt"
        
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(f"=== ๋‰ด์Šค ๋‹ค์ด์ œ์ŠคํŠธ ===\n")
            f.write(f"์ƒ์„ฑ ์‹œ๊ฐ„: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
            f.write(digest)
        
        logging.info(f"๐Ÿ“„ ๋‹ค์ด์ œ์ŠคํŠธ ์ €์žฅ: {filename}")
    
    def send_notification(self, summaries, digest):
        """์•Œ๋ฆผ ๋ฐœ์†ก (์ด๋ฉ”์ผ, ์Šฌ๋ž™ ๋“ฑ)"""
        # ์—ฌ๊ธฐ์„œ๋Š” ๊ฐ„๋‹จํžˆ ๋กœ๊ทธ๋กœ ๋Œ€์ฒด
        logging.info(f"๐Ÿ“ง ์•Œ๋ฆผ ๋ฐœ์†ก: {len(summaries)}๊ฐœ ๋‰ด์Šค ์š”์•ฝ ์™„๋ฃŒ")
        # ์‹ค์ œ๋กœ๋Š” ์ด๋ฉ”์ผ์ด๋‚˜ ์Šฌ๋ž™ API๋ฅผ ์‚ฌ์šฉ
    
    def start_scheduler(self):
        """์Šค์ผ€์ค„๋Ÿฌ ์‹œ์ž‘"""
        logging.info("โฐ ์Šค์ผ€์ค„๋Ÿฌ ์‹œ์ž‘")
        
        # ์„ค์ •๋œ ์‹œ๊ฐ„๋งˆ๋‹ค ์‹คํ–‰
        for time_str in self.config['schedule']['times']:
            schedule.every().day.at(time_str).do(self.run_news_cycle)
            logging.info(f"๐Ÿ“… ์Šค์ผ€์ค„ ๋“ฑ๋ก: ๋งค์ผ {time_str}")
        
        # ์ฆ‰์‹œ ํ•œ ๋ฒˆ ์‹คํ–‰
        self.run_news_cycle()
        
        # ๋ฌดํ•œ ๋ฃจํ”„๋กœ ์Šค์ผ€์ค„ ์ฒดํฌ
        while True:
            schedule.run_pending()
            time.sleep(60)  # 1๋ถ„๋งˆ๋‹ค ์ฒดํฌ

# ๋ด‡ ์‹คํ–‰
if __name__ == "__main__":
    bot = NewsAutomationBot()
    bot.start_scheduler()

์ด ์ž๋™ํ™” ์‹œ์Šคํ…œ์€ ์„ค์ •ํ•œ ์‹œ๊ฐ„๋งˆ๋‹ค ์ž๋™์œผ๋กœ ๋‰ด์Šค๋ฅผ ์ˆ˜์ง‘ํ•˜๊ณ  ์š”์•ฝํ•ด. ๊ทธ๋ฆฌ๊ณ  ๋ชจ๋“  ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์— ์ €์žฅํ•˜๊ณ  ๋กœ๊ทธ๋ฅผ ๋‚จ๊ฒจ์„œ ๋‚˜์ค‘์— ๋ถ„์„ํ•  ์ˆ˜ ์žˆ์–ด. ์ •๋ง ์™„์ „ํ•œ ์ž๋™ํ™” ๋ด‡์ด์ง€! ๐ŸŽ‰

โš ๏ธ ์šด์˜ ์‹œ ์ฃผ์˜์‚ฌํ•ญ โ€ข ์„œ๋ฒ„ ํ™˜๊ฒฝ: 24์‹œ๊ฐ„ ๋Œ์•„๊ฐ€๋Š” ์„œ๋ฒ„๊ฐ€ ํ•„์š”ํ•ด. AWS, GCP, ๋˜๋Š” ๋ผ์ฆˆ๋ฒ ๋ฆฌํŒŒ์ด๋„ ๊ฐ€๋Šฅํ•ด
โ€ข ์—๋Ÿฌ ๋ชจ๋‹ˆํ„ฐ๋ง: ์ •๊ธฐ์ ์œผ๋กœ ๋กœ๊ทธ๋ฅผ ํ™•์ธํ•˜๊ณ  ์˜ค๋ฅ˜์— ๋Œ€์‘ํ•ด์•ผ ํ•ด
โ€ข API ๋น„์šฉ: OpenAI API ์‚ฌ์šฉ๋Ÿ‰์„ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๊ณ  ์˜ˆ์‚ฐ์„ ๊ด€๋ฆฌํ•ด
โ€ข ์ €์ž‘๊ถŒ: ๋‰ด์Šค ์ฝ˜ํ…์ธ  ์‚ฌ์šฉ ์‹œ ์ €์ž‘๊ถŒ ๋ฌธ์ œ๋ฅผ ๊ณ ๋ คํ•ด์•ผ ํ•ด

๐Ÿ“Š ๋ฐ์ดํ„ฐ ์ €์žฅ ๋ฐ ๊ด€๋ฆฌ

์ˆ˜์ง‘ํ•˜๊ณ  ์š”์•ฝํ•œ ๋‰ด์Šค๋ฅผ ํšจ๊ณผ์ ์œผ๋กœ ์ €์žฅํ•˜๊ณ  ๊ด€๋ฆฌํ•˜๋Š” ๊ฒƒ๋„ ์ค‘์š”ํ•ด! ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์„ค๊ณ„๋ถ€ํ„ฐ ๋ฐฑ์—… ์ „๋žต๊นŒ์ง€ ์•Œ์•„๋ณด์ž. ๐Ÿ’พ

๐Ÿ—„๏ธ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์„ค๊ณ„

์œ„์—์„œ SQLite๋ฅผ ์‚ฌ์šฉํ–ˆ์ง€๋งŒ, ๋” ํฐ ๊ทœ๋ชจ์˜ ์„œ๋น„์Šค๋ผ๋ฉด PostgreSQL์ด๋‚˜ MongoDB๋ฅผ ๊ณ ๋ คํ•  ์ˆ˜ ์žˆ์–ด. ๊ฐ๊ฐ์˜ ์žฅ๋‹จ์ ์„ ์‚ดํŽด๋ณด์ž:

๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์žฅ์  ๋‹จ์  ์ ํ•ฉํ•œ ๊ฒฝ์šฐ
SQLite ์„ค์น˜ ๋ถˆํ•„์š”, ๊ฐ€๋ณ๊ณ  ๋น ๋ฆ„ ๋™์‹œ ์ ‘์† ์ œํ•œ, ํ™•์žฅ์„ฑ ๋‚ฎ์Œ ๊ฐœ์ธ ํ”„๋กœ์ ํŠธ, ํ”„๋กœํ† ํƒ€์ž…
PostgreSQL ๊ฐ•๋ ฅํ•œ ๊ธฐ๋Šฅ, ํ™•์žฅ์„ฑ ์šฐ์ˆ˜ ์„ค์ • ๋ณต์žก, ๋ฆฌ์†Œ์Šค ๋งŽ์ด ์‚ฌ์šฉ ์ค‘๋Œ€ํ˜• ์„œ๋น„์Šค, ๋ณต์žกํ•œ ์ฟผ๋ฆฌ
MongoDB ์œ ์—ฐํ•œ ์Šคํ‚ค๋งˆ, JSON ์นœํ™”์  ํŠธ๋žœ์žญ์…˜ ์ œํ•œ์  ๋น„์ •ํ˜• ๋ฐ์ดํ„ฐ, ๋น ๋ฅธ ๊ฐœ๋ฐœ
MySQL ๋„๋ฆฌ ์‚ฌ์šฉ๋จ, ์•ˆ์ •์  ์ผ๋ถ€ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ ๋ถ€์กฑ ์›น ์„œ๋น„์Šค, ๋ฒ”์šฉ ๋ชฉ์ 
# MongoDB๋ฅผ ์‚ฌ์šฉํ•œ ์˜ˆ์‹œ
from pymongo import MongoClient
from datetime import datetime

class MongoNewsStorage:
    def __init__(self, connection_string="mongodb://localhost:27017/"):
        self.client = MongoClient(connection_string)
        self.db = self.client['news_bot']
        self.summaries = self.db['summaries']
        self.logs = self.db['logs']
        
        # ์ธ๋ฑ์Šค ์ƒ์„ฑ
        self.summaries.create_index([('title', 'text'), ('summary', 'text')])
        self.summaries.create_index('summarized_at')
    
    def save_summary(self, summary_data):
        """์š”์•ฝ ์ €์žฅ"""
        document = {
            'title': summary_data['original_title'],
            'link': summary_data['original_link'],
            'summary': summary_data['summary'],
            'press': summary_data.get('press', ''),
            'tokens_used': summary_data['tokens_used'],
            'summarized_at': datetime.fromisoformat(summary_data['summarized_at']),
            'created_at': datetime.now()
        }
        
        result = self.summaries.insert_one(document)
        return result.inserted_id
    
    def search_summaries(self, keyword, limit=10):
        """ํ‚ค์›Œ๋“œ๋กœ ์š”์•ฝ ๊ฒ€์ƒ‰"""
        results = self.summaries.find(
            {'$text': {'$search': keyword}},
            {'score': {'$meta': 'textScore'}}
        ).sort([('score', {'$meta': 'textScore'})]).limit(limit)
        
        return list(results)
    
    def get_daily_stats(self, date=None):
        """์ผ์ผ ํ†ต๊ณ„"""
        if date is None:
            date = datetime.now()
        
        start_of_day = date.replace(hour=0, minute=0, second=0, microsecond=0)
        end_of_day = date.replace(hour=23, minute=59, second=59, microsecond=999999)
        
        pipeline = [
            {
                '$match': {
                    'summarized_at': {
                        '$gte': start_of_day,
                        '$lte': end_of_day
                    }
                }
            },
            {
                '$group': {
                    '_id': None,
                    'total_articles': {'$sum': 1},
                    'total_tokens': {'$sum': '$tokens_used'},
                    'presses': {'$addToSet': '$press'}
                }
            }
        ]
        
        result = list(self.summaries.aggregate(pipeline))
        return result[0] if result else None

MongoDB๋Š” JSON ํ˜•ํƒœ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•˜๊ธฐ ๋•Œ๋ฌธ์— AI๊ฐ€ ์ƒ์„ฑํ•œ ๊ตฌ์กฐํ™”๋œ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•˜๊ธฐ์— ์ •๋ง ํŽธ๋ฆฌํ•ด! ๊ทธ๋ฆฌ๊ณ  ์ „๋ฌธ ๊ฒ€์ƒ‰(Full-text search) ๊ธฐ๋Šฅ๋„ ๋‚ด์žฅ๋˜์–ด ์žˆ์–ด์„œ ๋‚˜์ค‘์— ๊ฒ€์ƒ‰ ๊ธฐ๋Šฅ์„ ์ถ”๊ฐ€ํ•˜๊ธฐ๋„ ์‰ฌ์›Œ. ๐Ÿ”

๐ŸŽจ ๊ฒฐ๊ณผ ์‹œ๊ฐํ™” ๋ฐ ๋Œ€์‹œ๋ณด๋“œ

์ˆ˜์ง‘ํ•œ ๋ฐ์ดํ„ฐ๋ฅผ ๋ณด๊ธฐ ์ข‹๊ฒŒ ์‹œ๊ฐํ™”ํ•˜๋ฉด ํ›จ์”ฌ ๋” ์œ ์šฉํ•ด! ๊ฐ„๋‹จํ•œ ์›น ๋Œ€์‹œ๋ณด๋“œ๋ฅผ ๋งŒ๋“ค์–ด์„œ ์š”์•ฝ๋œ ๋‰ด์Šค๋ฅผ ํ™•์ธํ•˜๊ณ , ํ†ต๊ณ„๋„ ๋ณผ ์ˆ˜ ์žˆ๊ฒŒ ํ•ด๋ณด์ž. ๐Ÿ“ˆ

from flask import Flask, render_template, jsonify
import sqlite3
from datetime import datetime, timedelta

app = Flask(__name__)

class NewsDashboard:
    def __init__(self, db_path='news_summaries.db'):
        self.db_path = db_path
    
    def get_recent_summaries(self, limit=20):
        """์ตœ๊ทผ ์š”์•ฝ ๊ฐ€์ ธ์˜ค๊ธฐ"""
        conn = sqlite3.connect(self.db_path)
        conn.row_factory = sqlite3.Row
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT * FROM news_summaries 
            ORDER BY summarized_at DESC 
            LIMIT ?
        ''', (limit,))
        
        results = [dict(row) for row in cursor.fetchall()]
        conn.close()
        return results
    
    def get_statistics(self, days=7):
        """ํ†ต๊ณ„ ๋ฐ์ดํ„ฐ"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        since_date = (datetime.now() - timedelta(days=days)).isoformat()
        
        # ์ด ๊ธฐ์‚ฌ ์ˆ˜
        cursor.execute('''
            SELECT COUNT(*) as total 
            FROM news_summaries 
            WHERE summarized_at > ?
        ''', (since_date,))
        total_articles = cursor.fetchone()[0]
        
        # ์ด ํ† ํฐ ์‚ฌ์šฉ๋Ÿ‰
        cursor.execute('''
            SELECT SUM(tokens_used) as total_tokens 
            FROM news_summaries 
            WHERE summarized_at > ?
        ''', (since_date,))
        total_tokens = cursor.fetchone()[0] or 0
        
        # ์–ธ๋ก ์‚ฌ๋ณ„ ํ†ต๊ณ„
        cursor.execute('''
            SELECT press, COUNT(*) as count 
            FROM news_summaries 
            WHERE summarized_at > ?
            GROUP BY press 
            ORDER BY count DESC 
            LIMIT 10
        ''', (since_date,))
        press_stats = cursor.fetchall()
        
        # ์ผ๋ณ„ ํ†ต๊ณ„
        cursor.execute('''
            SELECT DATE(summarized_at) as date, COUNT(*) as count 
            FROM news_summaries 
            WHERE summarized_at > ?
            GROUP BY DATE(summarized_at) 
            ORDER BY date DESC
        ''', (since_date,))
        daily_stats = cursor.fetchall()
        
        conn.close()
        
        return {
            'total_articles': total_articles,
            'total_tokens': total_tokens,
            'press_stats': press_stats,
            'daily_stats': daily_stats
        }

dashboard = NewsDashboard()

@app.route('/')
def index():
    """๋ฉ”์ธ ํŽ˜์ด์ง€"""
    summaries = dashboard.get_recent_summaries(20)
    stats = dashboard.get_statistics(7)
    return render_template('dashboard.html', summaries=summaries, stats=stats)

@app.route('/api/summaries')
def api_summaries():
    """API ์—”๋“œํฌ์ธํŠธ"""
    limit = request.args.get('limit', 20, type=int)
    summaries = dashboard.get_recent_summaries(limit)
    return jsonify(summaries)

@app.route('/api/stats')
def api_stats():
    """ํ†ต๊ณ„ API"""
    days = request.args.get('days', 7, type=int)
    stats = dashboard.get_statistics(days)
    return jsonify(stats)

if __name__ == '__main__':
    app.run(debug=True, port=5000)

Flask๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ •๋ง ๊ฐ„๋‹จํ•˜๊ฒŒ ์›น ๋Œ€์‹œ๋ณด๋“œ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด! ์—ฌ๊ธฐ์— Chart.js๋‚˜ D3.js ๊ฐ™์€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์ถ”๊ฐ€ํ•˜๋ฉด ๋ฉ‹์ง„ ๊ทธ๋ž˜ํ”„๋„ ๊ทธ๋ฆด ์ˆ˜ ์žˆ์ง€. ๐Ÿ“Šโœจ

๐Ÿ’ก ๋Œ€์‹œ๋ณด๋“œ ๊ฐœ์„  ์•„์ด๋””์–ด โ€ข ์‹ค์‹œ๊ฐ„ ์—…๋ฐ์ดํŠธ: WebSocket์„ ์‚ฌ์šฉํ•ด์„œ ์ƒˆ ์š”์•ฝ์ด ์ƒ์„ฑ๋˜๋ฉด ์ž๋™์œผ๋กœ ํ™”๋ฉด์— ํ‘œ์‹œ
โ€ข ์นดํ…Œ๊ณ ๋ฆฌ ํ•„ํ„ฐ: ์ •์น˜, ๊ฒฝ์ œ, ์‚ฌํšŒ ๋“ฑ ์นดํ…Œ๊ณ ๋ฆฌ๋ณ„๋กœ ํ•„ํ„ฐ๋ง
โ€ข ํ‚ค์›Œ๋“œ ํด๋ผ์šฐ๋“œ: ์ž์ฃผ ๋“ฑ์žฅํ•˜๋Š” ํ‚ค์›Œ๋“œ๋ฅผ ์‹œ๊ฐํ™”
โ€ข ํŠธ๋ Œ๋“œ ๋ถ„์„: ์‹œ๊ฐ„์— ๋”ฐ๋ฅธ ์ฃผ์ œ ๋ณ€ํ™” ์ถ”์ 
โ€ข ๊ฐ์„ฑ ๋ถ„์„: ๊ธ์ •/๋ถ€์ • ๋‰ด์Šค ๋น„์œจ ํ‘œ์‹œ

๐Ÿš€ ๋ฐฐํฌ ๋ฐ ์šด์˜

์ด์ œ ์™„์„ฑ๋œ ๋ด‡์„ ์‹ค์ œ๋กœ ๋ฐฐํฌํ•˜๊ณ  ์šด์˜ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์•Œ์•„๋ณด์ž! ๋กœ์ปฌ์—์„œ๋งŒ ๋Œ๋ฆฌ๋Š” ๊ฒƒ๊ณผ ์‹ค์ œ ์„œ๋น„์Šค๋กœ ์šด์˜ํ•˜๋Š” ๊ฑด ์™„์ „ํžˆ ๋‹ค๋ฅธ ์ฐจ์›์ด๊ฑฐ๋“ . ๐ŸŒ

โ˜๏ธ ํด๋ผ์šฐ๋“œ ๋ฐฐํฌ ์˜ต์…˜

๐ŸŒŸ ์ถ”์ฒœ ๋ฐฐํฌ ํ”Œ๋žซํผ AWS EC2: ๊ฐ€์žฅ ์œ ์—ฐํ•˜๊ณ  ๊ฐ•๋ ฅํ•จ. ์™„์ „ํ•œ ์ œ์–ด ๊ฐ€๋Šฅ
Google Cloud Run: ์ปจํ…Œ์ด๋„ˆ ๊ธฐ๋ฐ˜, ์ž๋™ ์Šค์ผ€์ผ๋ง
Heroku: ๊ฐ„๋‹จํ•œ ๋ฐฐํฌ, ์ดˆ๋ณด์ž ์นœํ™”์ 
DigitalOcean: ์ €๋ ดํ•˜๊ณ  ์‚ฌ์šฉํ•˜๊ธฐ ์‰ฌ์›€
๋ผ์ฆˆ๋ฒ ๋ฆฌํŒŒ์ด: ์ง‘์—์„œ 24์‹œ๊ฐ„ ์šด์˜, ๋น„์šฉ ์ ˆ๊ฐ
# Docker๋ฅผ ์‚ฌ์šฉํ•œ ๋ฐฐํฌ ์˜ˆ์‹œ
# Dockerfile
FROM python:3.9-slim

WORKDIR /app

# ์‹œ์Šคํ…œ ํŒจํ‚ค์ง€ ์„ค์น˜
RUN apt-get update && apt-get install -y \
    chromium \
    chromium-driver \
    && rm -rf /var/lib/apt/lists/*

# Python ํŒจํ‚ค์ง€ ์„ค์น˜
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ์ฝ”๋“œ ๋ณต์‚ฌ
COPY . .

# ํ™˜๊ฒฝ ๋ณ€์ˆ˜ ์„ค์ •
ENV PYTHONUNBUFFERED=1

# ๋ด‡ ์‹คํ–‰
CMD ["python", "news_bot.py"]
# docker-compose.yml
version: '3.8'

services:
  news-bot:
    build: .
    container_name: news_automation_bot
    restart: always
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
    networks:
      - news-network
  
  mongodb:
    image: mongo:latest
    container_name: news_mongodb
    restart: always
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db
    networks:
      - news-network
  
  dashboard:
    build:
      context: .
      dockerfile: Dockerfile.dashboard
    container_name: news_dashboard
    restart: always
    ports:
      - "5000:5000"
    depends_on:
      - mongodb
    networks:
      - news-network

networks:
  news-network:
    driver: bridge

volumes:
  mongodb_data:

Docker๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์–ด๋–ค ํ™˜๊ฒฝ์—์„œ๋“  ๋™์ผํ•˜๊ฒŒ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์–ด์„œ ์ •๋ง ํŽธ๋ฆฌํ•ด! ๊ฐœ๋ฐœ ํ™˜๊ฒฝ๊ณผ ํ”„๋กœ๋•์…˜ ํ™˜๊ฒฝ์˜ ์ฐจ์ด๋กœ ์ธํ•œ ๋ฌธ์ œ๋ฅผ ์™„์ „ํžˆ ์—†์•จ ์ˆ˜ ์žˆ์ง€. ๐Ÿณ

๐Ÿ“ˆ ๋ชจ๋‹ˆํ„ฐ๋ง ๋ฐ ์•Œ๋ฆผ

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import requests

class NotificationManager:
    def __init__(self, config):
        self.config = config
    
    def send_email(self, subject, body):
        """์ด๋ฉ”์ผ ์•Œ๋ฆผ"""
        try:
            msg = MIMEMultipart()
            msg['From'] = self.config['email']['from']
            msg['To'] = self.config['email']['to']
            msg['Subject'] = subject
            
            msg.attach(MIMEText(body, 'html'))
            
            server = smtplib.SMTP(self.config['email']['smtp_server'], 587)
            server.starttls()
            server.login(
                self.config['email']['username'],
                self.config['email']['password']
            )
            server.send_message(msg)
            server.quit()
            
            logging.info("๐Ÿ“ง ์ด๋ฉ”์ผ ๋ฐœ์†ก ์™„๋ฃŒ")
        except Exception as e:
            logging.error(f"์ด๋ฉ”์ผ ๋ฐœ์†ก ์‹คํŒจ: {e}")
    
    def send_slack(self, message):
        """์Šฌ๋ž™ ์•Œ๋ฆผ"""
        try:
            webhook_url = self.config['slack']['webhook_url']
            payload = {
                'text': message,
                'username': 'News Bot',
                'icon_emoji': ':newspaper:'
            }
            
            response = requests.post(webhook_url, json=payload)
            response.raise_for_status()
            
            logging.info("๐Ÿ’ฌ ์Šฌ๋ž™ ๋ฉ”์‹œ์ง€ ๋ฐœ์†ก ์™„๋ฃŒ")
        except Exception as e:
            logging.error(f"์Šฌ๋ž™ ๋ฐœ์†ก ์‹คํŒจ: {e}")
    
    def send_telegram(self, message):
        """ํ…”๋ ˆ๊ทธ๋žจ ์•Œ๋ฆผ"""
        try:
            bot_token = self.config['telegram']['bot_token']
            chat_id = self.config['telegram']['chat_id']
            
            url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
            payload = {
                'chat_id': chat_id,
                'text': message,
                'parse_mode': 'HTML'
            }
            
            response = requests.post(url, json=payload)
            response.raise_for_status()
            
            logging.info("๐Ÿ“ฑ ํ…”๋ ˆ๊ทธ๋žจ ๋ฉ”์‹œ์ง€ ๋ฐœ์†ก ์™„๋ฃŒ")
        except Exception as e:
            logging.error(f"ํ…”๋ ˆ๊ทธ๋žจ ๋ฐœ์†ก ์‹คํŒจ: {e}")
    
    def format_summary_notification(self, summaries):
        """์š”์•ฝ ์•Œ๋ฆผ ํฌ๋งทํŒ…"""
        html = "<h2>๐Ÿ“ฐ ์˜ค๋Š˜์˜ ๋‰ด์Šค ์š”์•ฝ</h2>"
        html += f"<p>์ด {len(summaries)}๊ฐœ์˜ ๋‰ด์Šค๊ฐ€ ์š”์•ฝ๋˜์—ˆ์Šต๋‹ˆ๋‹ค.</p>"
        html += "<hr>"
        
        for i, summary in enumerate(summaries[:5], 1):
            html += f"<h3>{i}. {summary['original_title']}</h3>"
            html += f"<p>{summary['summary']}</p>"
            html += f"<p><a href='{summary['original_link']}'>์›๋ฌธ ๋ณด๊ธฐ</a></p>"
            html += "<hr>"
        
        return html

์•Œ๋ฆผ ์‹œ์Šคํ…œ์„ ๊ตฌ์ถ•ํ•˜๋ฉด ๋ด‡์ด ์ œ๋Œ€๋กœ ๋™์ž‘ํ•˜๋Š”์ง€ ์‹ค์‹œ๊ฐ„์œผ๋กœ ํ™•์ธํ•  ์ˆ˜ ์žˆ์–ด. ํŠนํžˆ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์„ ๋•Œ ์ฆ‰์‹œ ์•Œ ์ˆ˜ ์žˆ์–ด์„œ ๋น ๋ฅด๊ฒŒ ๋Œ€์‘ํ•  ์ˆ˜ ์žˆ์ง€! ๐Ÿ””

โšก ์„ฑ๋Šฅ ์ตœ์ ํ™” ๋ฐ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ

๊ธฐ๋ณธ ๊ธฐ๋Šฅ์ด ์™„์„ฑ๋˜์—ˆ๋‹ค๋ฉด, ์ด์ œ ์„ฑ๋Šฅ์„ ์ตœ์ ํ™”ํ•˜๊ณ  ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ์„ ์ถ”๊ฐ€ํ•ด๋ณผ ์ฐจ๋ก€์•ผ! ๋” ๋น ๋ฅด๊ณ , ๋” ๋˜‘๋˜‘ํ•˜๊ณ , ๋” ์œ ์šฉํ•œ ๋ด‡์œผ๋กœ ๋งŒ๋“ค์–ด๋ณด์ž. ๐Ÿš€

โš™๏ธ ์„ฑ๋Šฅ ์ตœ์ ํ™” ๊ธฐ๋ฒ•

๐ŸŽฏ ์ตœ์ ํ™” ํฌ์ธํŠธ ์บ์‹ฑ: ์ค‘๋ณต ์š”์ฒญ ๋ฐฉ์ง€, ์‘๋‹ต ์†๋„ ํ–ฅ์ƒ
๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ: ์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์‹คํ–‰
๋ฐฐ์น˜ ์ฒ˜๋ฆฌ: ์—ฌ๋Ÿฌ ์š”์ฒญ์„ ๋ฌถ์–ด์„œ ์ฒ˜๋ฆฌ
๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ธ๋ฑ์‹ฑ: ์ฟผ๋ฆฌ ์†๋„ ๊ฐœ์„ 
๋ฆฌ์†Œ์Šค ํ’€๋ง: ์—ฐ๊ฒฐ ์žฌ์‚ฌ์šฉ์œผ๋กœ ์˜ค๋ฒ„ํ—ค๋“œ ๊ฐ์†Œ
import asyncio
import aiohttp
from functools import lru_cache
import hashlib

class OptimizedNewsCrawler:
    def __init__(self):
        self.session = None
        self.cache = {}
    
    async def create_session(self):
        """๋น„๋™๊ธฐ ์„ธ์…˜ ์ƒ์„ฑ"""
        if self.session is None:
            self.session = aiohttp.ClientSession()
        return self.session
    
    @lru_cache(maxsize=1000)
    def get_cache_key(self, url):
        """URL์„ ์บ์‹œ ํ‚ค๋กœ ๋ณ€ํ™˜"""
        return hashlib.md5(url.encode()).hexdigest()
    
    async def fetch_with_cache(self, url, cache_ttl=3600):
        """์บ์‹œ๋ฅผ ํ™œ์šฉํ•œ ํŽ˜์ด์ง€ ๊ฐ€์ ธ์˜ค๊ธฐ"""
        cache_key = self.get_cache_key(url)
        
        # ์บ์‹œ ํ™•์ธ
        if cache_key in self.cache:
            cached_data, timestamp = self.cache[cache_key]
            if time.time() - timestamp < cache_ttl:
                logging.info(f"๐Ÿ’พ ์บ์‹œ ํžˆํŠธ: {url}")
                return cached_data
        
        # ์ƒˆ๋กœ ๊ฐ€์ ธ์˜ค๊ธฐ
        session = await self.create_session()
        async with session.get(url) as response:
            html = await response.text()
            self.cache[cache_key] = (html, time.time())
            return html
    
    async def fetch_multiple(self, urls):
        """์—ฌ๋Ÿฌ URL์„ ๋™์‹œ์— ๊ฐ€์ ธ์˜ค๊ธฐ"""
        tasks = [self.fetch_with_cache(url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return results
    
    async def parallel_crawl(self, news_sources, max_articles=10):
        """๋ณ‘๋ ฌ ํฌ๋กค๋ง"""
        all_articles = []
        
        for source in news_sources:
            try:
                html = await self.fetch_with_cache(source['url'])
                articles = self.parse_news_list(html)
                
                # ๊ฐ ๊ธฐ์‚ฌ์˜ ๋ณธ๋ฌธ์„ ๋ณ‘๋ ฌ๋กœ ๊ฐ€์ ธ์˜ค๊ธฐ
                article_urls = [a['link'] for a in articles[:max_articles]]
                contents = await self.fetch_multiple(article_urls)
                
                for article, content in zip(articles, contents):
                    if not isinstance(content, Exception):
                        article['content'] = self.extract_content(content)
                        all_articles.append(article)
                
            except Exception as e:
                logging.error(f"ํฌ๋กค๋ง ์˜ค๋ฅ˜: {e}")
        
        return all_articles
    
    async def close(self):
        """์„ธ์…˜ ์ข…๋ฃŒ"""
        if self.session:
            await self.session.close()

# ์‚ฌ์šฉ ์˜ˆ์‹œ
async def main():
    crawler = OptimizedNewsCrawler()
    
    news_sources = [
        {'url': 'https://news.example1.com'},
        {'url': 'https://news.example2.com'},
        {'url': 'https://news.example3.com'}
    ]
    
    articles = await crawler.parallel_crawl(news_sources, max_articles=10)
    await crawler.close()
    
    return articles

# ์‹คํ–‰
articles = asyncio.run(main())

๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์‚ฌ์šฉํ•˜๋ฉด ํฌ๋กค๋ง ์†๋„๊ฐ€ ์—„์ฒญ๋‚˜๊ฒŒ ๋นจ๋ผ์ ธ! 10๊ฐœ์˜ ํŽ˜์ด์ง€๋ฅผ ์ˆœ์ฐจ์ ์œผ๋กœ ๊ฐ€์ ธ์˜ค๋ฉด 10์ดˆ๊ฐ€ ๊ฑธ๋ฆฌ์ง€๋งŒ, ๋น„๋™๊ธฐ๋กœ ์ฒ˜๋ฆฌํ•˜๋ฉด 1-2์ดˆ๋ฉด ์ถฉ๋ถ„ํ•ด. ์ด๊ฒŒ ๋ฐ”๋กœ ๋น„๋™๊ธฐ์˜ ๋งˆ๋ฒ•์ด์•ผ! โœจ

๐Ÿง  ๊ณ ๊ธ‰ AI ๊ธฐ๋Šฅ

class AdvancedAIFeatures:
    def __init__(self, openai_api_key):
        self.api_key = openai_api_key
        openai.api_key = openai_api_key
    
    def sentiment_analysis(self, text):
        """๊ฐ์„ฑ ๋ถ„์„"""
        prompt = f"""๋‹ค์Œ ๋‰ด์Šค ๊ธฐ์‚ฌ์˜ ๊ฐ์„ฑ์„ ๋ถ„์„ํ•ด์ฃผ์„ธ์š”.
        
๊ธฐ์‚ฌ: {text[:1000]}

๋‹ค์Œ ํ˜•์‹์œผ๋กœ ๋‹ต๋ณ€ํ•ด์ฃผ์„ธ์š”:
- ์ „์ฒด ๊ฐ์„ฑ: ๊ธ์ •/์ค‘๋ฆฝ/๋ถ€์ •
- ๊ฐ์„ฑ ์ ์ˆ˜: -1.0 ~ 1.0
- ์ฃผ์š” ๊ฐ์ •: ๊ธฐ์จ, ๋ถ„๋…ธ, ์Šฌํ””, ๋†€๋ผ์›€ ๋“ฑ
- ์ด์œ : ๊ฐ„๋‹จํ•œ ์„ค๋ช…"""
        
        response = openai.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "๋‹น์‹ ์€ ๊ฐ์„ฑ ๋ถ„์„ ์ „๋ฌธ๊ฐ€์ž…๋‹ˆ๋‹ค."},
                {"role": "user", "content": prompt}
            ]
        )
        
        return response.choices[0].message.content
    
    def extract_entities(self, text):
        """๊ฐœ์ฒด๋ช… ์ธ์‹ (NER)"""
        prompt = f"""๋‹ค์Œ ๋‰ด์Šค์—์„œ ์ฃผ์š” ๊ฐœ์ฒด๋ฅผ ์ถ”์ถœํ•ด์ฃผ์„ธ์š”.
        
๊ธฐ์‚ฌ: {text[:1000]}

JSON ํ˜•์‹์œผ๋กœ ๋‹ต๋ณ€:
{{
    "people": ["์ธ๋ฌผ1", "์ธ๋ฌผ2"],
    "organizations": ["๊ธฐ๊ด€1", "๊ธฐ๊ด€2"],
    "locations": ["์žฅ์†Œ1", "์žฅ์†Œ2"],
    "dates": ["๋‚ ์งœ1", "๋‚ ์งœ2"],
    "money": ["๊ธˆ์•ก1", "๊ธˆ์•ก2"]
}}"""
        
        response = openai.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"}
        )
        
        return json.loads(response.choices[0].message.content)
    
    def categorize_news(self, title, summary):
        """๋‰ด์Šค ์นดํ…Œ๊ณ ๋ฆฌ ๋ถ„๋ฅ˜"""
        categories = [
            "์ •์น˜", "๊ฒฝ์ œ", "์‚ฌํšŒ", "๋ฌธํ™”", "๊ตญ์ œ", 
            "๊ณผํ•™๊ธฐ์ˆ ", "์Šคํฌ์ธ ", "์—ฐ์˜ˆ", "๊ฑด๊ฐ•", "๊ต์œก"
        ]
        
        prompt = f"""๋‹ค์Œ ๋‰ด์Šค๋ฅผ ๊ฐ€์žฅ ์ ํ•ฉํ•œ ์นดํ…Œ๊ณ ๋ฆฌ๋กœ ๋ถ„๋ฅ˜ํ•ด์ฃผ์„ธ์š”.
        
์ œ๋ชฉ: {title}
์š”์•ฝ: {summary}

์นดํ…Œ๊ณ ๋ฆฌ ๋ชฉ๋ก: {', '.join(categories)}

๊ฐ€์žฅ ์ ํ•ฉํ•œ ์นดํ…Œ๊ณ ๋ฆฌ 1๊ฐœ๋งŒ ๋‹ต๋ณ€ํ•ด์ฃผ์„ธ์š”."""
        
        response = openai.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=20
        )
        
        return response.choices[0].message.content.strip()
    
    def generate_headline(self, summary):
        """์š”์•ฝ์—์„œ ํ—ค๋“œ๋ผ์ธ ์ƒ์„ฑ"""
        prompt = f"""๋‹ค์Œ ๋‰ด์Šค ์š”์•ฝ์„ ๋ฐ”ํƒ•์œผ๋กœ ๋งค๋ ฅ์ ์ธ ํ—ค๋“œ๋ผ์ธ์„ ๋งŒ๋“ค์–ด์ฃผ์„ธ์š”.
        
์š”์•ฝ: {summary}

ํ—ค๋“œ๋ผ์ธ ์ž‘์„ฑ ๊ทœ์น™:
- 15-20์ž ์ด๋‚ด
- ํ•ต์‹ฌ ๋‚ด์šฉ ํฌํ•จ
- ํด๋ฆญ์„ ์œ ๋„ํ•˜๋Š” ํ‘œํ˜„
- ๊ณผ์žฅ ๊ธˆ์ง€

ํ—ค๋“œ๋ผ์ธ:"""
        
        response = openai.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=50
        )
        
        return response.choices[0].message.content.strip()
    
    def compare_articles(self, articles):
        """์—ฌ๋Ÿฌ ๊ธฐ์‚ฌ ๋น„๊ต ๋ถ„์„"""
        articles_text = "\n\n".join([
            f"๊ธฐ์‚ฌ {i+1}: {a['title']}\n{a['summary']}"
            for i, a in enumerate(articles)
        ])
        
        prompt = f"""๋‹ค์Œ ์—ฌ๋Ÿฌ ๋‰ด์Šค ๊ธฐ์‚ฌ๋“ค์„ ๋น„๊ต ๋ถ„์„ํ•ด์ฃผ์„ธ์š”.
        
{articles_text}

๋ถ„์„ ๋‚ด์šฉ:
1. ๊ณตํ†ต ์ฃผ์ œ
2. ๊ด€์ ์˜ ์ฐจ์ด
3. ์ถ”๊ฐ€ ์ •๋ณด๊ฐ€ ์žˆ๋Š” ๊ธฐ์‚ฌ
4. ๊ฐ€์žฅ ๊ฐ๊ด€์ ์ธ ๊ธฐ์‚ฌ
5. ์ข…ํ•ฉ ์˜๊ฒฌ"""
        
        response = openai.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=800
        )
        
        return response.choices[0].message.content

์ด๋Ÿฐ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ๋“ค์„ ์ถ”๊ฐ€ํ•˜๋ฉด ๋‹จ์ˆœํ•œ ์š”์•ฝ ๋ด‡์„ ๋„˜์–ด์„œ ์ง„์งœ ๋˜‘๋˜‘ํ•œ ๋‰ด์Šค ๋ถ„์„ ์‹œ์Šคํ…œ์ด ๋ผ! ๊ฐ์„ฑ ๋ถ„์„์œผ๋กœ ๋‰ด์Šค์˜ ๋ถ„์œ„๊ธฐ๋ฅผ ํŒŒ์•…ํ•˜๊ณ , ๊ฐœ์ฒด๋ช… ์ธ์‹์œผ๋กœ ์ฃผ์š” ์ธ๋ฌผ๊ณผ ๊ธฐ๊ด€์„ ์ถ”์ถœํ•˜๊ณ , ์ž๋™ ์นดํ…Œ๊ณ ๋ฆฌ ๋ถ„๋ฅ˜๊นŒ์ง€... ์ •๋ง ๊ฐ•๋ ฅํ•˜์ง€? ๐Ÿ’ช

๐Ÿ”’ ๋ณด์•ˆ ๋ฐ ์œค๋ฆฌ์  ๊ณ ๋ ค์‚ฌํ•ญ

๊ธฐ์ˆ ์ ์œผ๋กœ ์™„๋ฒฝํ•œ ๋ด‡์„ ๋งŒ๋“ค์—ˆ๋‹ค๊ณ  ํ•ด๋„, ๋ณด์•ˆ๊ณผ ์œค๋ฆฌ๋ฅผ ๋ฌด์‹œํ•˜๋ฉด ํฐ ๋ฌธ์ œ๊ฐ€ ์ƒ๊ธธ ์ˆ˜ ์žˆ์–ด. ์ฑ…์ž„๊ฐ ์žˆ๋Š” ๊ฐœ๋ฐœ์ž๊ฐ€ ๋˜๊ธฐ ์œ„ํ•ด ๊ผญ ์•Œ์•„์•ผ ํ•  ๋‚ด์šฉ๋“ค์ด์•ผ! ๐Ÿ›ก๏ธ

โš ๏ธ ๋ฒ•์  ๋ฐ ์œค๋ฆฌ์  ์ฃผ์˜์‚ฌํ•ญ ์ €์ž‘๊ถŒ ๋ฌธ์ œ
โ€ข ๋‰ด์Šค ์ฝ˜ํ…์ธ ๋Š” ์ €์ž‘๊ถŒ์œผ๋กœ ๋ณดํ˜ธ๋ฐ›๋Š” ์ €์ž‘๋ฌผ์ด์•ผ
โ€ข ๋‹จ์ˆœ ๋งํฌ ๊ณต์œ ๋Š” ๊ดœ์ฐฎ์ง€๋งŒ, ์ „๋ฌธ ๋ณต์ œ๋Š” ๋ฌธ์ œ๊ฐ€ ๋  ์ˆ˜ ์žˆ์–ด
โ€ข ์š”์•ฝ์€ '๊ณต์ • ์ด์šฉ(Fair Use)' ๋ฒ”์œ„ ๋‚ด์—์„œ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ, ์ƒ์—…์  ์ด์šฉ์€ ์ฃผ์˜ํ•ด์•ผ ํ•ด
โ€ข ์ถœ์ฒ˜๋ฅผ ๋ช…ํ™•ํžˆ ํ‘œ์‹œํ•˜๊ณ , ์›๋ฌธ ๋งํฌ๋ฅผ ํ•จ๊ป˜ ์ œ๊ณตํ•˜๋Š” ๊ฒŒ ์ข‹์•„

๊ฐœ์ธ์ •๋ณด ๋ณดํ˜ธ
โ€ข API ํ‚ค, ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ๋น„๋ฐ€๋ฒˆํ˜ธ ๋“ฑ์€ ์ ˆ๋Œ€ ๊ณต๊ฐœํ•˜๋ฉด ์•ˆ ๋ผ
โ€ข ํ™˜๊ฒฝ ๋ณ€์ˆ˜๋‚˜ ๋น„๋ฐ€ ๊ด€๋ฆฌ ์„œ๋น„์Šค๋ฅผ ์‚ฌ์šฉํ•ด
โ€ข ์ˆ˜์ง‘ํ•œ ๋ฐ์ดํ„ฐ์— ๊ฐœ์ธ์ •๋ณด๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ๋‹ค๋ฉด ์ ์ ˆํžˆ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•ด

์›น์‚ฌ์ดํŠธ ์ด์šฉ ๊ทœ์น™
โ€ข robots.txt๋ฅผ ํ™•์ธํ•˜๊ณ  ์ค€์ˆ˜ํ•ด
โ€ข ๊ณผ๋„ํ•œ ์š”์ฒญ์œผ๋กœ ์„œ๋ฒ„์— ๋ถ€๋‹ด์„ ์ฃผ์ง€ ๋งˆ
โ€ข ์ด์šฉ ์•ฝ๊ด€์„ ์œ„๋ฐ˜ํ•˜์ง€ ์•Š๋„๋ก ์ฃผ์˜ํ•ด
import os
from cryptography.fernet import Fernet
import keyring

class SecureConfigManager:
    def __init__(self):
        self.cipher_key = self.get_or_create_key()
        self.cipher = Fernet(self.cipher_key)
    
    def get_or_create_key(self):
        """์•”ํ˜ธํ™” ํ‚ค ๊ฐ€์ ธ์˜ค๊ธฐ ๋˜๋Š” ์ƒ์„ฑ"""
        key = keyring.get_password("news_bot", "cipher_key")
        if key is None:
            key = Fernet.generate_key().decode()
            keyring.set_password("news_bot", "cipher_key", key)
        return key.encode()
    
    def encrypt_api_key(self, api_key):
        """API ํ‚ค ์•”ํ˜ธํ™”"""
        return self.cipher.encrypt(api_key.encode()).decode()
    
    def decrypt_api_key(self, encrypted_key):
        """API ํ‚ค ๋ณตํ˜ธํ™”"""
        return self.cipher.decrypt(encrypted_key.encode()).decode()
    
    def save_secure_config(self, config):
        """๋ณด์•ˆ ์„ค์ • ์ €์žฅ"""
        # ๋ฏผ๊ฐํ•œ ์ •๋ณด ์•”ํ˜ธํ™”
        if 'openai_api_key' in config:
            config['openai_api_key'] = self.encrypt_api_key(config['openai_api_key'])
        
        if 'database_password' in config:
            config['database_password'] = self.encrypt_api_key(config['database_password'])
        
        # ์•”ํ˜ธํ™”๋œ ์„ค์ • ์ €์žฅ
        with open('config.encrypted.json', 'w') as f:
            json.dump(config, f)
    
    def load_secure_config(self):
        """๋ณด์•ˆ ์„ค์ • ๋กœ๋“œ"""
        with open('config.encrypted.json', 'r') as f:
            config = json.load(f)
        
        # ๋ณตํ˜ธํ™”
        if 'openai_api_key' in config:
            config['openai_api_key'] = self.decrypt_api_key(config['openai_api_key'])
        
        if 'database_password' in config:
            config['database_password'] = self.decrypt_api_key(config['database_password'])
        
        return config

class RateLimiter:
    """์š”์ฒญ ์†๋„ ์ œํ•œ"""
    def __init__(self, max_requests_per_minute=60):
        self.max_requests = max_requests_per_minute
        self.requests = []
    
    def can_make_request(self):
        """์š”์ฒญ ๊ฐ€๋Šฅ ์—ฌ๋ถ€ ํ™•์ธ"""
        now = time.time()
        # 1๋ถ„ ์ด๋‚ด์˜ ์š”์ฒญ๋งŒ ์œ ์ง€
        self.requests = [req_time for req_time in self.requests 
                        if now - req_time < 60]
        
        if len(self.requests) < self.max_requests:
            self.requests.append(now)
            return True
        return False
    
    def wait_if_needed(self):
        """ํ•„์š”์‹œ ๋Œ€๊ธฐ"""
        while not self.can_make_request():
            time.sleep(1)

class EthicalCrawler:
    """์œค๋ฆฌ์  ํฌ๋กค๋ง์„ ์œ„ํ•œ ํด๋ž˜์Šค"""
    def __init__(self, user_agent, respect_robots_txt=True):
        self.user_agent = user_agent
        self.respect_robots_txt = respect_robots_txt
        self.rate_limiter = RateLimiter(max_requests_per_minute=30)
    
    def check_robots_txt(self, url):
        """robots.txt ํ™•์ธ"""
        if not self.respect_robots_txt:
            return True
        
        from urllib.robotparser import RobotFileParser
        from urllib.parse import urlparse
        
        parsed = urlparse(url)
        robots_url = f"{parsed.scheme}://{parsed.netloc}/robots.txt"
        
        rp = RobotFileParser()
        rp.set_url(robots_url)
        try:
            rp.read()
            return rp.can_fetch(self.user_agent, url)
        except:
            # robots.txt๋ฅผ ์ฝ์„ ์ˆ˜ ์—†์œผ๋ฉด ํ—ˆ์šฉ์œผ๋กœ ๊ฐ„์ฃผ
            return True
    
    def crawl_with_ethics(self, url):
        """์œค๋ฆฌ์  ํฌ๋กค๋ง"""
        # robots.txt ํ™•์ธ
        if not self.check_robots_txt(url):
            logging.warning(f"robots.txt์— ์˜ํ•ด ์ฐจ๋‹จ๋จ: {url}")
            return None
        
        # ์†๋„ ์ œํ•œ
        self.rate_limiter.wait_if_needed()
        
        # ํฌ๋กค๋ง ์‹คํ–‰
        try:
            response = requests.get(url, headers={'User-Agent': self.user_agent})
            return response.text
        except Exception as e:
            logging.error(f"ํฌ๋กค๋ง ์˜ค๋ฅ˜: {e}")
            return None

๋ณด์•ˆ๊ณผ ์œค๋ฆฌ๋Š” ์„ ํƒ์ด ์•„๋‹ˆ๋ผ ํ•„์ˆ˜์•ผ! ํŠนํžˆ ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค์ด ์‚ฌ์šฉํ•  ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ ๋‹ค๋ฉด ๋”์šฑ ์‹ ๊ฒฝ ์จ์•ผ ํ•ด. ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•  ๋•Œ๋„ ์ด๋Ÿฐ ๋ถ€๋ถ„๋“ค์ด ์ •๋ง ์ค‘์š”ํ•˜๊ฑฐ๋“ ! ๐Ÿ”

๐Ÿ’ผ ์‹ค์ „ ํ™œ์šฉ ์‚ฌ๋ก€ ๋ฐ ์ˆ˜์ตํ™”

์ด์ œ ์™„์„ฑ๋œ ๋‰ด์Šค์š”์•ฝ ๋ด‡์„ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•˜๊ณ  ์ˆ˜์ตํ™”ํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์•Œ์•„๋ณด์ž! ๊ธฐ์ˆ ๋งŒ ์•„๋Š” ๊ฒƒ๋ณด๋‹ค ์‹ค์ œ๋กœ ๊ฐ€์น˜๋ฅผ ์ฐฝ์ถœํ•˜๋Š” ๊ฒŒ ๋” ์ค‘์š”ํ•˜๋‹ˆ๊นŒ! ๐Ÿ’ฐ

๐ŸŽฏ ์‹ค์ „ ํ™œ์šฉ ์•„์ด๋””์–ด 1. ๊ฐœ์ธ ๋‰ด์Šค๋ ˆํ„ฐ ์„œ๋น„์Šค
๋งค์ผ ์•„์นจ ๊ตฌ๋…์ž๋“ค์—๊ฒŒ ๋งž์ถคํ˜• ๋‰ด์Šค ์š”์•ฝ์„ ์ด๋ฉ”์ผ๋กœ ๋ฐœ์†กํ•ด. Substack์ด๋‚˜ Mailchimp๋ฅผ ํ™œ์šฉํ•˜๋ฉด ์‰ฝ๊ฒŒ ์‹œ์ž‘ํ•  ์ˆ˜ ์žˆ์–ด.

2. ํ…”๋ ˆ๊ทธ๋žจ/์Šฌ๋ž™ ๋ด‡
ํŠน์ • ์ฃผ์ œ๋‚˜ ํ‚ค์›Œ๋“œ์— ๋Œ€ํ•œ ๋‰ด์Šค๋ฅผ ์‹ค์‹œ๊ฐ„์œผ๋กœ ์•Œ๋ ค์ฃผ๋Š” ๋ด‡์„ ๋งŒ๋“ค์–ด. ๊ธฐ์—…์ด๋‚˜ ํŒ€์—์„œ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์ง€.

3. ์—…๊ณ„๋ณ„ ๋‰ด์Šค ํ๋ ˆ์ด์…˜
IT, ๊ธˆ์œต, ๋ถ€๋™์‚ฐ ๋“ฑ ํŠน์ • ์‚ฐ์—…์— ํŠนํ™”๋œ ๋‰ด์Šค ์š”์•ฝ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•ด. ์ „๋ฌธ๊ฐ€๋“ค์ด ๊ธฐ๊บผ์ด ๋น„์šฉ์„ ์ง€๋ถˆํ•  ๊ฑฐ์•ผ.

4. ๊ธฐ์—…์šฉ ๋ฏธ๋””์–ด ๋ชจ๋‹ˆํ„ฐ๋ง
๊ธฐ์—…์˜ ๋ธŒ๋žœ๋“œ๋‚˜ ๊ฒฝ์Ÿ์‚ฌ์— ๋Œ€ํ•œ ๋‰ด์Šค๋ฅผ ์ž๋™์œผ๋กœ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๊ณ  ๋ฆฌํฌํŠธ๋ฅผ ์ƒ์„ฑํ•ด์ค˜.

5. ์ฝ˜ํ…์ธ  ํฌ๋ฆฌ์—์ดํ„ฐ ์ง€์›
์œ ํŠœ๋ฒ„๋‚˜ ๋ธ”๋กœ๊ฑฐ๋“ค์—๊ฒŒ ํŠธ๋ Œ๋“œ ๋‰ด์Šค ์ •๋ณด๋ฅผ ์ œ๊ณตํ•ด์„œ ์ฝ˜ํ…์ธ  ์•„์ด๋””์–ด๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๊ฒŒ ๋„์™€์ค˜.

๐Ÿ’ต ์ˆ˜์ตํ™” ์ „๋žต

์ˆ˜์ต ๋ชจ๋ธ ์„ค๋ช… ์˜ˆ์ƒ ์ˆ˜์ต ๋‚œ์ด๋„
๊ตฌ๋… ์„œ๋น„์Šค ์›” ์ •์•ก์ œ๋กœ ํ”„๋ฆฌ๋ฏธ์—„ ๊ธฐ๋Šฅ ์ œ๊ณต ์›” 5,000~50,000์›/์ธ ์ค‘๊ฐ„
API ํŒ๋งค ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค์—๊ฒŒ API ์ œ๊ณต ์‚ฌ์šฉ๋Ÿ‰ ๊ธฐ๋ฐ˜ ๋†’์Œ
๋งž์ถค ๊ฐœ๋ฐœ ๊ธฐ์—…์šฉ ์ปค์Šคํ„ฐ๋งˆ์ด์ง• ์„œ๋น„์Šค ํ”„๋กœ์ ํŠธ๋‹น 100๋งŒ์›~ ์ค‘๊ฐ„
๊ด‘๊ณ  ์ˆ˜์ต ๋ฌด๋ฃŒ ์„œ๋น„์Šค์— ๊ด‘๊ณ  ์‚ฝ์ž… ํŠธ๋ž˜ํ”ฝ ๊ธฐ๋ฐ˜ ๋‚ฎ์Œ
๋ฐ์ดํ„ฐ ํŒ๋งค ์ˆ˜์ง‘๋œ ๋‰ด์Šค ๋ฐ์ดํ„ฐ ํŒ๋งค ๋ณ€๋™์  ๋†’์Œ
class NewsSubscriptionService:
    """๊ตฌ๋… ์„œ๋น„์Šค ๊ด€๋ฆฌ"""
    def __init__(self):
        self.plans = {
            'free': {
                'name': '๋ฌด๋ฃŒ',
                'price': 0,
                'features': {
                    'daily_summaries': 5,
                    'categories': ['์ •์น˜', '๊ฒฝ์ œ'],
                    'email_delivery': True,
                    'api_access': False
                }
            },
            'basic': {
                'name': '๋ฒ ์ด์ง',
                'price': 9900,
                'features': {
                    'daily_summaries': 20,
                    'categories': 'all',
                    'email_delivery': True,
                    'api_access': False,
                    'custom_keywords': 5
                }
            },
            'pro': {
                'name': 'ํ”„๋กœ',
                'price': 29900,
                'features': {
                    'daily_summaries': 'unlimited',
                    'categories': 'all',
                    'email_delivery': True,
                    'api_access': True,
                    'custom_keywords': 'unlimited',
                    'sentiment_analysis': True,
                    'priority_support': True
                }
            }
        }
    
    def check_user_limit(self, user_id, feature):
        """์‚ฌ์šฉ์ž ์ œํ•œ ํ™•์ธ"""
        user_plan = self.get_user_plan(user_id)
        plan_features = self.plans[user_plan]['features']
        
        if feature in plan_features:
            limit = plan_features[feature]
            if limit == 'unlimited' or limit is True:
                return True
            
            # ์‚ฌ์šฉ๋Ÿ‰ ํ™•์ธ
            usage = self.get_user_usage(user_id, feature)
            return usage < limit
        
        return False
    
    def generate_invoice(self, user_id, plan):
        """์ฒญ๊ตฌ์„œ ์ƒ์„ฑ"""
        user = self.get_user(user_id)
        plan_info = self.plans[plan]
        
        invoice = {
            'user_id': user_id,
            'user_email': user['email'],
            'plan': plan,
            'amount': plan_info['price'],
            'billing_date': datetime.now().isoformat(),
            'next_billing_date': (datetime.now() + timedelta(days=30)).isoformat()
        }
        
        return invoice

๊ตฌ๋… ์„œ๋น„์Šค๋ฅผ ์šด์˜ํ•˜๋ ค๋ฉด ๊ฒฐ์ œ ์‹œ์Šคํ…œ๋„ ํ•„์š”ํ•ด. Stripe๋‚˜ ํ† ์ŠคํŽ˜์ด๋จผ์ธ  ๊ฐ™์€ ์„œ๋น„์Šค๋ฅผ ์—ฐ๋™ํ•˜๋ฉด ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์–ด. ๊ทธ๋ฆฌ๊ณ  ์žฌ๋Šฅ๋„ท์—์„œ๋„ ์ด๋Ÿฐ ์ž๋™ํ™” ์„œ๋น„์Šค๋ฅผ ํŒ๋งคํ•  ์ˆ˜ ์žˆ์œผ๋‹ˆ, ํ”Œ๋žซํผ์„ ํ™œ์šฉํ•˜๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ! ๐ŸŽช

๐ŸŽ“ ํ•™์Šต ๋ฆฌ์†Œ์Šค ๋ฐ ๋‹ค์Œ ๋‹จ๊ณ„

์—ฌ๊ธฐ๊นŒ์ง€ ๋”ฐ๋ผ์™”๋‹ค๋ฉด ์ •๋ง ๋Œ€๋‹จํ•ด! ํ•˜์ง€๋งŒ ํ•™์Šต์€ ์—ฌ๊ธฐ์„œ ๋์ด ์•„๋‹ˆ์•ผ. ๊ณ„์† ๋ฐœ์ „ํ•˜๊ณ  ๋” ๋‚˜์€ ๊ฐœ๋ฐœ์ž๊ฐ€ ๋˜๊ธฐ ์œ„ํ•œ ๋ฆฌ์†Œ์Šค๋“ค์„ ์†Œ๊ฐœํ• ๊ฒŒ! ๐Ÿ“š

๐Ÿ“– ์ถ”์ฒœ ํ•™์Šต ์ž๋ฃŒ ๊ณต์‹ ๋ฌธ์„œ
โ€ข OpenAI API Documentation: platform.openai.com/docs
โ€ข Beautiful Soup Documentation: www.crummy.com/software/BeautifulSoup/bs4/doc/
โ€ข Selenium Documentation: selenium-python.readthedocs.io

์˜จ๋ผ์ธ ๊ฐ•์˜
โ€ข "Web Scraping with Python" - Udemy
โ€ข "OpenAI API ๋งˆ์Šคํ„ฐํ•˜๊ธฐ" - ์ธํ”„๋Ÿฐ
โ€ข "Python ์ž๋™ํ™” ์™„์ „์ •๋ณต" - ๋…ธ๋งˆ๋“œ์ฝ”๋”

์ปค๋ฎค๋‹ˆํ‹ฐ
โ€ข Reddit r/webscraping
โ€ข Stack Overflow
โ€ข ์ƒํ™œ์ฝ”๋”ฉ ์ปค๋ฎค๋‹ˆํ‹ฐ
โ€ข ๊ฐœ๋ฐœ์ž ์นดํŽ˜ (๋„ค์ด๋ฒ„, ๋””์Šค์ฝ”๋“œ)

๐Ÿš€ ๋‹ค์Œ ๋‹จ๊ณ„ ํ”„๋กœ์ ํŠธ ์•„์ด๋””์–ด

๋ ˆ๋ฒจ 1: ๊ธฐ๋Šฅ ํ™•์žฅ

โœ… ๋‹ค๊ตญ์–ด ๋‰ด์Šค ์ง€์› (๋ฒˆ์—ญ ๊ธฐ๋Šฅ ์ถ”๊ฐ€)
โœ… ์Œ์„ฑ ์š”์•ฝ (TTS ์—ฐ๋™)
โœ… ์ด๋ฏธ์ง€ ๋ถ„์„ (๋‰ด์Šค ์‚ฌ์ง„ ์„ค๋ช…)
โœ… ํŒฉํŠธ์ฒดํฌ ๊ธฐ๋Šฅ
โœ… ๊ด€๋ จ ๋‰ด์Šค ์ถ”์ฒœ
๋ ˆ๋ฒจ 2: ๊ณ ๊ธ‰ AI ํ™œ์šฉ

โœ… ๋ฉ€ํ‹ฐ๋ชจ๋‹ฌ ๋ถ„์„ (ํ…์ŠคํŠธ + ์ด๋ฏธ์ง€)
โœ… ํŠธ๋ Œ๋“œ ์˜ˆ์ธก
โœ… ๊ฐ€์งœ๋‰ด์Šค ํƒ์ง€
โœ… ์ž๋™ ํŒŸ์บ์ŠคํŠธ ์ƒ์„ฑ
โœ… ์ธํ„ฐ๋ž™ํ‹ฐ๋ธŒ ์ฑ—๋ด‡
๋ ˆ๋ฒจ 3: ํ”Œ๋žซํผ ๊ตฌ์ถ•

โœ… ๋ชจ๋ฐ”์ผ ์•ฑ ๊ฐœ๋ฐœ
โœ… ์†Œ์…œ ๋ฏธ๋””์–ด ์—ฐ๋™
โœ… ์ปค๋ฎค๋‹ˆํ‹ฐ ๊ธฐ๋Šฅ
โœ… ๋งˆ์ผ“ํ”Œ๋ ˆ์ด์Šค
โœ… ํ™”์ดํŠธ๋ผ๋ฒจ ์†”๋ฃจ์…˜
# ๋‹ค๊ตญ์–ด ์ง€์› ์˜ˆ์‹œ
from googletrans import Translator

class MultilingualNewsBot:
    def __init__(self):
        self.translator = Translator()
        self.supported_languages = ['ko', 'en', 'ja', 'zh-cn', 'es']
    
    def translate_summary(self, summary, target_lang='en'):
        """์š”์•ฝ ๋ฒˆ์—ญ"""
        try:
            result = self.translator.translate(summary, dest=target_lang)
            return result.text
        except Exception as e:
            logging.error(f"๋ฒˆ์—ญ ์˜ค๋ฅ˜: {e}")
            return summary
    
    def multilingual_summary(self, article):
        """๋‹ค๊ตญ์–ด ์š”์•ฝ ์ƒ์„ฑ"""
        # ํ•œ๊ตญ์–ด๋กœ ์š”์•ฝ
        korean_summary = self.summarize_article(article)
        
        # ์—ฌ๋Ÿฌ ์–ธ์–ด๋กœ ๋ฒˆ์—ญ
        translations = {}
        for lang in self.supported_languages:
            if lang != 'ko':
                translations[lang] = self.translate_summary(korean_summary, lang)
        
        return {
            'ko': korean_summary,
            **translations
        }

# ์Œ์„ฑ ์š”์•ฝ ์˜ˆ์‹œ
from gtts import gTTS
import os

class VoiceNewsBot:
    def __init__(self):
        self.output_dir = 'voice_summaries'
        os.makedirs(self.output_dir, exist_ok=True)
    
    def text_to_speech(self, text, filename, lang='ko'):
        """ํ…์ŠคํŠธ๋ฅผ ์Œ์„ฑ์œผ๋กœ ๋ณ€ํ™˜"""
        try:
            tts = gTTS(text=text, lang=lang, slow=False)
            filepath = os.path.join(self.output_dir, filename)
            tts.save(filepath)
            logging.info(f"๐Ÿ”Š ์Œ์„ฑ ํŒŒ์ผ ์ƒ์„ฑ: {filepath}")
            return filepath
        except Exception as e:
            logging.error(f"TTS ์˜ค๋ฅ˜: {e}")
            return None
    
    def create_news_podcast(self, summaries):
        """๋‰ด์Šค ํŒŸ์บ์ŠคํŠธ ์ƒ์„ฑ"""
        intro = "์•ˆ๋…•ํ•˜์„ธ์š”. ์˜ค๋Š˜์˜ ์ฃผ์š” ๋‰ด์Šค๋ฅผ ์ „ํ•ด๋“œ๋ฆฝ๋‹ˆ๋‹ค."
        
        full_script = intro + "\n\n"
        for i, summary in enumerate(summaries, 1):
            full_script += f"{i}๋ฒˆ์งธ ๋‰ด์Šค. {summary['original_title']}. "
            full_script += f"{summary['summary']}\n\n"
        
        outro = "์ด์ƒ ์˜ค๋Š˜์˜ ๋‰ด์Šค์˜€์Šต๋‹ˆ๋‹ค. ๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค."
        full_script += outro
        
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filename = f"news_podcast_{timestamp}.mp3"
        
        return self.text_to_speech(full_script, filename)

์ด๋Ÿฐ ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ๋“ค์„ ํ•˜๋‚˜์”ฉ ์ถ”๊ฐ€ํ•˜๋‹ค ๋ณด๋ฉด ์ •๋ง ๊ฐ•๋ ฅํ•œ ๋‰ด์Šค ํ”Œ๋žซํผ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด! ์ค‘์š”ํ•œ ๊ฑด ํ•œ ๋ฒˆ์— ๋‹ค ํ•˜๋ ค๊ณ  ํ•˜์ง€ ๋ง๊ณ , ํ•˜๋‚˜์”ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ๊ตฌํ˜„ํ•˜๋Š” ๊ฑฐ์•ผ. ๐ŸŽฏ

๐Ÿ› ํŠธ๋Ÿฌ๋ธ”์ŠˆํŒ… ๊ฐ€์ด๋“œ

๊ฐœ๋ฐœํ•˜๋‹ค ๋ณด๋ฉด ๋ฐ˜๋“œ์‹œ ๋ฌธ์ œ๊ฐ€ ์ƒ๊ฒจ. ์—ฌ๊ธฐ ์ž์ฃผ ๋ฐœ์ƒํ•˜๋Š” ๋ฌธ์ œ๋“ค๊ณผ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์ •๋ฆฌํ•ด๋’€์–ด! ๐Ÿ”ง

โ“ ์ž์ฃผ ๋ฐœ์ƒํ•˜๋Š” ๋ฌธ์ œ๋“ค ๋ฌธ์ œ 1: "OpenAI API rate limit exceeded"
์›์ธ: API ํ˜ธ์ถœ ํšŸ์ˆ˜ ์ œํ•œ ์ดˆ๊ณผ
ํ•ด๊ฒฐ: ์š”์ฒญ ๊ฐ„ ๋”œ๋ ˆ์ด ์ถ”๊ฐ€, ๋ฐฐ์น˜ ํฌ๊ธฐ ์ค„์ด๊ธฐ, ์œ ๋ฃŒ ํ”Œ๋žœ ์—…๊ทธ๋ ˆ์ด๋“œ

๋ฌธ์ œ 2: "Connection timeout"
์›์ธ: ๋„คํŠธ์›Œํฌ ๋ถˆ์•ˆ์ • ๋˜๋Š” ์„œ๋ฒ„ ์‘๋‹ต ์ง€์—ฐ
ํ•ด๊ฒฐ: timeout ๊ฐ’ ์ฆ๊ฐ€, ์žฌ์‹œ๋„ ๋กœ์ง ์ถ”๊ฐ€, ํ”„๋ก์‹œ ์‚ฌ์šฉ

๋ฌธ์ œ 3: "Element not found"
์›์ธ: ์›น์‚ฌ์ดํŠธ ๊ตฌ์กฐ ๋ณ€๊ฒฝ ๋˜๋Š” ๋™์  ๋กœ๋”ฉ
ํ•ด๊ฒฐ: ์…€๋ ‰ํ„ฐ ์—…๋ฐ์ดํŠธ, ๋Œ€๊ธฐ ์‹œ๊ฐ„ ์ถ”๊ฐ€, ๋™์  ํฌ๋กค๋ง ์‚ฌ์šฉ

๋ฌธ์ œ 4: "IP blocked"
์›์ธ: ๊ณผ๋„ํ•œ ์š”์ฒญ์œผ๋กœ IP ์ฐจ๋‹จ
ํ•ด๊ฒฐ: ์š”์ฒญ ๊ฐ„๊ฒฉ ๋Š˜๋ฆฌ๊ธฐ, ํ”„๋ก์‹œ ๋กœํ…Œ์ด์…˜, User-Agent ๋ณ€๊ฒฝ

๋ฌธ์ œ 5: "Out of memory"
์›์ธ: ๋Œ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
ํ•ด๊ฒฐ: ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ, ์ŠคํŠธ๋ฆฌ๋ฐ ๋ฐฉ์‹ ์‚ฌ์šฉ, ๋ฉ”๋ชจ๋ฆฌ ์ตœ์ ํ™”
class RobustNewsCrawler:
    """์•ˆ์ •์ ์ธ ํฌ๋กค๋Ÿฌ (์—๋Ÿฌ ์ฒ˜๋ฆฌ ๊ฐ•ํ™”)"""
    def __init__(self, max_retries=3):
        self.max_retries = max_retries
    
    def fetch_with_retry(self, url, retry_count=0):
        """์žฌ์‹œ๋„ ๋กœ์ง์ด ์žˆ๋Š” ํŽ˜์ด์ง€ ๊ฐ€์ ธ์˜ค๊ธฐ"""
        try:
            response = requests.get(
                url,
                headers={'User-Agent': self.get_random_user_agent()},
                timeout=10
            )
            response.raise_for_status()
            return response.text
            
        except requests.Timeout:
            if retry_count < self.max_retries:
                logging.warning(f"ํƒ€์ž„์•„์›ƒ ๋ฐœ์ƒ. ์žฌ์‹œ๋„ {retry_count + 1}/{self.max_retries}")
                time.sleep(2 ** retry_count)  # ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„
                return self.fetch_with_retry(url, retry_count + 1)
            else:
                logging.error(f"์ตœ๋Œ€ ์žฌ์‹œ๋„ ํšŸ์ˆ˜ ์ดˆ๊ณผ: {url}")
                return None
                
        except requests.HTTPError as e:
            if e.response.status_code == 429:  # Too Many Requests
                wait_time = int(e.response.headers.get('Retry-After', 60))
                logging.warning(f"Rate limit. {wait_time}์ดˆ ๋Œ€๊ธฐ")
                time.sleep(wait_time)
                return self.fetch_with_retry(url, retry_count + 1)
            else:
                logging.error(f"HTTP ์˜ค๋ฅ˜ {e.response.status_code}: {url}")
                return None
                
        except Exception as e:
            logging.error(f"์˜ˆ์ƒ์น˜ ๋ชปํ•œ ์˜ค๋ฅ˜: {e}")
            return None
    
    def get_random_user_agent(self):
        """๋žœ๋ค User-Agent ๋ฐ˜ํ™˜"""
        user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
        ]
        return random.choice(user_agents)
    
    def safe_parse(self, html, selector):
        """์•ˆ์ „ํ•œ ํŒŒ์‹ฑ"""
        try:
            soup = BeautifulSoup(html, 'html.parser')
            elements = soup.select(selector)
            return elements if elements else []
        except Exception as e:
            logging.error(f"ํŒŒ์‹ฑ ์˜ค๋ฅ˜: {e}")
            return []

# ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ์ธ ์ฒ˜๋ฆฌ
def process_large_dataset(articles, batch_size=10):
    """๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ"""
    for i in range(0, len(articles), batch_size):
        batch = articles[i:i + batch_size]
        
        # ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ
        process_batch(batch)
        
        # ๋ฉ”๋ชจ๋ฆฌ ์ •๋ฆฌ
        import gc
        gc.collect()
        
        logging.info(f"์ฒ˜๋ฆฌ ์™„๋ฃŒ: {i + len(batch)}/{len(articles)}")

์—๋Ÿฌ ์ฒ˜๋ฆฌ๋ฅผ ์ž˜ ํ•ด๋‘๋ฉด ๋ด‡์ด ํ›จ์”ฌ ์•ˆ์ •์ ์œผ๋กœ ๋™์ž‘ํ•ด. ํŠนํžˆ 24์‹œ๊ฐ„ ๋Œ์•„๊ฐ€๋Š” ์ž๋™ํ™” ์‹œ์Šคํ…œ์—์„œ๋Š” ์—๋Ÿฌ ์ฒ˜๋ฆฌ๊ฐ€ ์ •๋ง ์ค‘์š”ํ•˜๊ฑฐ๋“ ! ๐Ÿ’ช

๐ŸŽ‰ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€! ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์ง€? ์šฐ๋ฆฌ๋Š” OpenAI API์™€ ํฌ๋กค๋Ÿฌ๋ฅผ ๊ฒฐํ•ฉํ•ด์„œ ์™„์ „ํ•œ ๋‰ด์Šค์š”์•ฝ ์ž๋™๋ด‡์„ ๋งŒ๋“ค์–ด๋ดค์–ด. ์›น ํฌ๋กค๋ง๋ถ€ํ„ฐ AI ์š”์•ฝ, ์ž๋™ํ™”, ๋ฐฐํฌ, ์ˆ˜์ตํ™”๊นŒ์ง€... ์ •๋ง ๋งŽ์€ ๊ฑธ ๋‹ค๋ค˜์ง€! ๐Ÿš€

์ด ํ”„๋กœ์ ํŠธ๋ฅผ ํ†ตํ•ด ๋ฐฐ์šด ๊ธฐ์ˆ ๋“ค์€ ๋‹จ์ˆœํžˆ ๋‰ด์Šค ๋ด‡์—๋งŒ ์ ์šฉ๋˜๋Š” ๊ฒŒ ์•„๋‹ˆ์•ผ. ์›น ํฌ๋กค๋ง, API ์—ฐ๋™, ์ž๋™ํ™” ์‹œ์Šคํ…œ ๊ตฌ์ถ• ๊ฐ™์€ ์Šคํ‚ฌ๋“ค์€ ์ •๋ง ๋‹ค์–‘ํ•œ ํ”„๋กœ์ ํŠธ์— ํ™œ์šฉํ•  ์ˆ˜ ์žˆ์–ด. ์˜ˆ๋ฅผ ๋“ค๋ฉด:

๐ŸŒŸ ์‘์šฉ ๊ฐ€๋Šฅํ•œ ๋‹ค๋ฅธ ํ”„๋กœ์ ํŠธ๋“ค โ€ข ๐Ÿ“Š ์ฃผ์‹/์•”ํ˜ธํ™”ํ ๊ฐ€๊ฒฉ ๋ชจ๋‹ˆํ„ฐ๋ง ๋ด‡
โ€ข ๐Ÿ  ๋ถ€๋™์‚ฐ ๋งค๋ฌผ ์ž๋™ ์ˆ˜์ง‘ ์‹œ์Šคํ…œ
โ€ข ๐Ÿ›’ ์‡ผํ•‘๋ชฐ ๊ฐ€๊ฒฉ ๋น„๊ต ์„œ๋น„์Šค
โ€ข ๐Ÿ“ ๋ธ”๋กœ๊ทธ ์ž๋™ ํฌ์ŠคํŒ… ๋„๊ตฌ
โ€ข ๐Ÿ“ง ์ด๋ฉ”์ผ ์ž๋™ ๋ถ„๋ฅ˜ ๋ฐ ์š”์•ฝ
โ€ข ๐ŸŽฌ ์˜ํ™”/๋“œ๋ผ๋งˆ ๋ฆฌ๋ทฐ ์ˆ˜์ง‘ ๋ฐ ๋ถ„์„
โ€ข ๐Ÿ“ฑ ์†Œ์…œ ๋ฏธ๋””์–ด ํŠธ๋ Œ๋“œ ๋ถ„์„
โ€ข ๐ŸŽ“ ์˜จ๋ผ์ธ ๊ฐ•์˜ ์ž๋™ ์š”์•ฝ

๊ฐ€์žฅ ์ค‘์š”ํ•œ ๊ฑด ์ง์ ‘ ๋งŒ๋“ค์–ด๋ณด๋Š” ๊ฒƒ์ด์•ผ! ์ด ๊ธ€์„ ์ฝ๊ธฐ๋งŒ ํ•˜์ง€ ๋ง๊ณ , ์‹ค์ œ๋กœ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•˜๊ณ  ์‹คํ–‰ํ•ด๋ณด๋ฉด์„œ ๋ฐฐ์›Œ์•ผ ํ•ด. ์ฒ˜์Œ์—” ์—๋Ÿฌ๋„ ๋งŽ์ด ๋‚˜๊ณ  ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„๋„ ์žˆ๊ฒ ์ง€๋งŒ, ๊ทธ๊ฒŒ ๋ฐ”๋กœ ์„ฑ์žฅํ•˜๋Š” ๊ณผ์ •์ด์•ผ! ๐Ÿ’ช

๊ทธ๋ฆฌ๊ณ  ํ˜ผ์ž์„œ ๋‹ค ํ•˜๋ ค๊ณ  ํ•˜์ง€ ๋งˆ. ๋ง‰ํžˆ๋ฉด ์ปค๋ฎค๋‹ˆํ‹ฐ์— ์งˆ๋ฌธํ•˜๊ณ , ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค์˜ ์ฝ”๋“œ๋„ ์ฐธ๊ณ ํ•˜๊ณ , ํ˜‘์—…๋„ ํ•ด๋ด. ๊ฐœ๋ฐœ์€ ํ˜ผ์ž ํ•˜๋Š” ๊ฒŒ ์•„๋‹ˆ๋ผ ํ•จ๊ป˜ ํ•˜๋Š” ๊ฑฐ๋‹ˆ๊นŒ! ๐Ÿค

๋งˆ์ง€๋ง‰์œผ๋กœ, ์ด๋Ÿฐ ์ž๋™ํ™” ๊ธฐ์ˆ ์„ ์ตํ˜€๋‘๋ฉด ์ •๋ง ๋งŽ์€ ๊ธฐํšŒ๊ฐ€ ์ƒ๊ฒจ. ํ”„๋ฆฌ๋žœ์„œ๋กœ ์ผํ•  ์ˆ˜๋„ ์žˆ๊ณ , ์ž์‹ ๋งŒ์˜ ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ค ์ˆ˜๋„ ์žˆ๊ณ , ๊ธฐ์—…์—์„œ ๋†’์€ ํ‰๊ฐ€๋ฅผ ๋ฐ›์„ ์ˆ˜๋„ ์žˆ์–ด. ํŠนํžˆ ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์ด๋Ÿฐ ๊ธฐ์ˆ ์„ ํ™œ์šฉํ•œ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•˜๋ฉด ์ข‹์€ ์ˆ˜์ต๋„ ์–ป์„ ์ˆ˜ ์žˆ์ง€! ๐Ÿ’ผ

์ž, ์ด์ œ ๋‹น์‹  ์ฐจ๋ก€์•ผ! ์ด ๊ฐ€์ด๋“œ๋ฅผ ๋ฐ”ํƒ•์œผ๋กœ ์ž์‹ ๋งŒ์˜ ๋ฉ‹์ง„ ๋‰ด์Šค์š”์•ฝ ๋ด‡์„ ๋งŒ๋“ค์–ด๋ด. ๊ทธ๋ฆฌ๊ณ  ๋” ๋‚˜์•„๊ฐ€์„œ ์„ธ์ƒ์— ์—†๋˜ ์ƒˆ๋กœ์šด ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ค์–ด๋ณด๋Š” ๊ฑด ์–ด๋•Œ? ๋‹น์‹ ์ด๋ผ๋ฉด ์ถฉ๋ถ„ํžˆ ํ•  ์ˆ˜ ์žˆ์–ด! ๐ŸŒŸ

ํ–‰์šด์„ ๋นŒ์–ด! ๊ทธ๋ฆฌ๊ณ  ๋ฉ‹์ง„ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค๋ฉด ๊ผญ ๊ณต์œ ํ•ด์ค˜. ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค์—๊ฒŒ๋„ ์˜๊ฐ์„ ์ค„ ์ˆ˜ ์žˆ์„ ํ…Œ๋‹ˆ๊นŒ! ํ™”์ดํŒ…! ๐ŸŽŠ

๐ŸŽ ๋ณด๋„ˆ์Šค ํŒ โ€ข GitHub์— ํ”„๋กœ์ ํŠธ๋ฅผ ์˜ฌ๋ ค์„œ ํฌํŠธํด๋ฆฌ์˜ค๋กœ ํ™œ์šฉํ•ด
โ€ข ๋ธ”๋กœ๊ทธ์— ๊ฐœ๋ฐœ ๊ณผ์ •์„ ๊ธฐ๋กํ•˜๋ฉด ๋‚˜์ค‘์— ํฐ ์ž์‚ฐ์ด ๋ผ
โ€ข ์˜คํ”ˆ์†Œ์Šค๋กœ ๊ณต๊ฐœํ•˜๋ฉด ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค๊ณผ ํ˜‘์—…ํ•  ์ˆ˜ ์žˆ์–ด
โ€ข ์ •๊ธฐ์ ์œผ๋กœ ์ฝ”๋“œ๋ฅผ ๋ฆฌํŒฉํ† ๋งํ•˜๊ณ  ๊ฐœ์„ ํ•ด
โ€ข ์ƒˆ๋กœ์šด ๊ธฐ์ˆ ์ด ๋‚˜์˜ค๋ฉด ์ ๊ทน์ ์œผ๋กœ ์‹œ๋„ํ•ด๋ด
โ€ข ๋ฌด์—‡๋ณด๋‹ค ์ฆ๊ธฐ๋ฉด์„œ ๊ฐœ๋ฐœํ•˜๋Š” ๊ฒŒ ๊ฐ€์žฅ ์ค‘์š”ํ•ด! ๐Ÿ˜Š

๐ŸŽ“ ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์–ด์ฃผ์…”์„œ ์ •๋ง ๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค!

์ด์ œ ๋‹น์‹ ๋„ AI ์ž๋™ํ™” ์ „๋ฌธ๊ฐ€์˜ ๊ธธ๋กœ ํ•œ ๊ฑธ์Œ ๋” ๋‚˜์•„๊ฐ”์–ด์š”.
๊ณ„์†ํ•ด์„œ ๋ฐฐ์šฐ๊ณ , ๋งŒ๋“ค๊ณ , ๊ณต์œ ํ•˜์„ธ์š”! ๐Ÿš€

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.