Ver3.0 ๐ค Gemini API๋ก ์ ํ๋ธ ์์ ์๋์์ฝ ๋ด ๋ง๋ค๊ธฐ: ๋น์ ์ ์๊ฐ์ ์ ์ฝํ๋ AI ๋น์ ๊ฐ๋ฐ ๊ฐ์ด๋

๐ค Gemini API๋ก ์ ํ๋ธ ์์ ์๋์์ฝ ๋ด ๋ง๋ค๊ธฐ: ๋น์ ์ ์๊ฐ์ ์ ์ฝํ๋ AI ๋น์ ๊ฐ๋ฐ ๊ฐ์ด๋
AI ๊ธฐ์ ๋ก ์์ ์ฝํ ์ธ ๋ฅผ ํ ์คํธ๋ก ๋ณํํ๊ณ ํต์ฌ๋ง ์์ ๋ฝ์๋ด๋ ์๋ํ ์์คํ ๊ตฌ์ถํ๊ธฐ โก
๐ก ์ด๋ฐ ๊ฒฝํ ์์ง ์์?
์ ํ๋ธ์์ 1์๊ฐ์ง๋ฆฌ ๊ฐ์ ์์์ ๋ด์ผ ํ๋๋ฐ, ์๊ฐ์ ์๊ณ ... ํต์ฌ ๋ด์ฉ๋ง ๋น ๋ฅด๊ฒ ํ์
ํ๊ณ ์ถ์ ๋ ๋ง์ด์ผ. ๋๋ ์ฌ๋ฌ ๊ฐ์ ์์์ ๋น๊ต ๋ถ์ํด์ผ ํ๋๋ฐ, ์ผ์ผ์ด ๋ค ๋ณด๊ธฐ์ ๋๋ฌด ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆด ๋! ๐ฌ
๋ฐ๋ก ์ด๋ด ๋ ํ์ํ ๊ฒ ์ ํ๋ธ ์์ ์๋์์ฝ ๋ด์ด์ผ. ๊ทธ๋ฆฌ๊ณ Google์ Gemini API๋ฅผ ํ์ฉํ๋ฉด ์๊ฐ๋ณด๋ค ํจ์ฌ ์ฝ๊ฒ ๋ง๋ค ์ ์์ด. ์ด ๊ธ์์๋ ์ค์ ๋ก ์๋ํ๋ ์๋์์ฝ ๋ด์ ์ฒ์๋ถํฐ ๋๊น์ง ํจ๊ป ๋ง๋ค์ด๋ณผ ๊ฑฐ์ผ! ๐
๐ฏ ์ Gemini API๋ฅผ ์ ํํด์ผ ํ ๊น?
AI ์๋ํ ํ๋ก์ ํธ๋ฅผ ์์ํ ๋ ๊ฐ์ฅ ๋จผ์ ๊ณ ๋ฏผํ๋ ๊ฒ "์ด๋ค AI ๋ชจ๋ธ์ ์ธ๊น?"์์. OpenAI์ GPT, Anthropic์ Claude, ๊ทธ๋ฆฌ๊ณ Google์ Gemini๊น์ง... ์ ํ์ง๊ฐ ๋ง์์ ์คํ๋ ค ํท๊ฐ๋ฆด ์ ์์ด. ๐ต
ํ์ง๋ง ์ ํ๋ธ ์์ ์์ฝ ๋ด์ ๋ง๋ค ๋๋ Gemini API๊ฐ ํนํ ๊ฐ๋ ฅํ ์ด์ ๊ฐ ์์ด!
๐ Gemini API์ ํต์ฌ ์ฅ์
1๏ธโฃ ๋ฉํฐ๋ชจ๋ฌ ์ฒ๋ฆฌ ๋ฅ๋ ฅ
Gemini๋ ํ
์คํธ๋ฟ๋ง ์๋๋ผ ์ด๋ฏธ์ง, ์ค๋์ค, ๋น๋์ค๊น์ง ํ ๋ฒ์ ์ฒ๋ฆฌํ ์ ์์ด. ์ ํ๋ธ ์์์ ์๋ง๊ณผ ์์ ๋ด์ฉ์ ๋์์ ๋ถ์ํ ์ ์๋ค๋ ๋ป์ด์ง! ์ด๊ฑด ํ
์คํธ๋ง ์ฒ๋ฆฌํ๋ ๋ชจ๋ธ๊ณผ๋ ์ฐจ์์ด ๋ค๋ฅธ ๊ฐ์ ์ด์ผ. ๐ฅ
2๏ธโฃ ๊ธด ์ปจํ
์คํธ ์๋์ฐ
Gemini 1.5 Pro ๋ชจ๋ธ์ ์ต๋ 100๋ง ํ ํฐ๊น์ง ์ฒ๋ฆฌํ ์ ์์ด. ์ด๊ฒ ์ผ๋ง๋ ๋๋จํ ๊ฑฐ๋๋ฉด, 1์๊ฐ์ง๋ฆฌ ์์์ ์ ์ฒด ์๋ง์ ํ ๋ฒ์ ๋ฃ์ด๋ ๋ฌธ์ ์๋ค๋ ๊ฑฐ์ผ. ๋ค๋ฅธ ๋ชจ๋ธ๋ค์ ์ค๊ฐ์ค๊ฐ ์๋ผ์ ์ฒ๋ฆฌํด์ผ ํ๋๋ฐ, Gemini๋ ๊ทธ๋ด ํ์๊ฐ ์์ง! ๐
3๏ธโฃ ํฉ๋ฆฌ์ ์ธ ๊ฐ๊ฒฉ
๋ฌด๋ฃ ํฐ์ด์์๋ ๋ถ๋น 15๊ฐ์ ์์ฒญ์ ๋ณด๋ผ ์ ์๊ณ , ์ ๋ฃ๋ก ์ ํํด๋ ๋ค๋ฅธ ํ๋ฆฌ๋ฏธ์ AI ๋ชจ๋ธ๋ค๋ณด๋ค ๊ฐ์ฑ๋น๊ฐ ์ข์. ๊ฐ์ธ ํ๋ก์ ํธ๋ ์คํํธ์
์์ ๋ถ๋ด ์์ด ์์ํ ์ ์๋ ์์ค์ด์ผ. ๐ฐ
4๏ธโฃ Google ์ํ๊ณ์์ ํตํฉ
์ ํ๋ธ๊ฐ Google ์๋น์ค์์? Gemini API๋ Google Cloud ํ๋ซํผ ์์ ์์ด์, ๋์ค์ YouTube Data API๋ ๋ค๋ฅธ Google ์๋น์ค๋ค๊ณผ ์ฐ๋ํ๊ธฐ๊ฐ ํจ์ฌ ์์ํด. ๐
๐ ๏ธ ํ๋ก์ ํธ ์ค๋นํ๊ธฐ: ํ์ํ ๊ฒ๋ค
๋ณธ๊ฒฉ์ ์ผ๋ก ์ฝ๋ฉ์ ๋ค์ด๊ฐ๊ธฐ ์ ์, ํ์ํ ๋๊ตฌ๋ค์ ๋จผ์ ์ค๋นํด๋ณด์. ๊ฑฑ์ ํ์ง ๋ง! ์ ๋ถ ๋ฌด๋ฃ๋ก ์์ํ ์ ์์ด. ๐
๐ ์ฒดํฌ๋ฆฌ์คํธ
โ
Google Cloud ๊ณ์
Gemini API๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด Google Cloud ๊ณ์ ์ด ํ์ํด. ์ด๋ฏธ Gmail ๊ณ์ ์ด ์๋ค๋ฉด ๊ทธ๊ฑธ๋ก ๋ฐ๋ก ์์ํ ์ ์์ด!
โ
Python 3.8 ์ด์
์ฐ๋ฆฌ๋ Python์ผ๋ก ๋ด์ ๋ง๋ค ๊ฑฐ์ผ. Python 3.8 ๋ฒ์ ์ด์์ด๋ฉด ์ถฉ๋ถํด. ์ต์ ๋ฒ์ ์ผ์๋ก ์ข์ง๋ง, 3.8๋ง ๋์ด๋ ๋ฌธ์ ์์ด.
โ
ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- google-generativeai (Gemini API ํด๋ผ์ด์ธํธ)
- youtube-transcript-api (์ ํ๋ธ ์๋ง ์ถ์ถ)
- python-dotenv (ํ๊ฒฝ๋ณ์ ๊ด๋ฆฌ)
- requests (HTTP ์์ฒญ ์ฒ๋ฆฌ)
โ
์ฝ๋ ์๋ํฐ
VS Code, PyCharm, ๋๋ ๋ค๊ฐ ํธํ ์๋ฌด ์๋ํฐ๋ ๊ด์ฐฎ์. ๋๋ VS Code๋ฅผ ์ถ์ฒํ๋๋ฐ, ๋ฌด๋ฃ๊ณ ํ์ฅ ๊ธฐ๋ฅ๋ ๋ง๊ฑฐ๋ ! ๐ป
๐ Gemini API ํค ๋ฐ๊ธ๋ฐ๊ธฐ
๊ฐ์ฅ ๋จผ์ ํด์ผ ํ ์ผ์ API ํค๋ฅผ ๋ฐ๋ ๊ฑฐ์ผ. ์ด๊ฒ ์์ผ๋ฉด ์์๋ ๋ชป ํ๋๊น ์ฐจ๊ทผ์ฐจ๊ทผ ๋ฐ๋ผ์๋ด!
Step 1: Google AI Studio ์ ์
https://makersuite.google.com/app/apikey ๋ก ๋ค์ด๊ฐ. Google ๊ณ์ ์ผ๋ก ๋ก๊ทธ์ธํ๋ฉด ๋ผ.
Step 2: API ํค ์์ฑ
"Create API Key" ๋ฒํผ์ ํด๋ฆญํ๋ฉด ๋ฐ๋ก ํค๊ฐ ์์ฑ๋ผ. ์ด ํค๋ ์ ๋ ๋ค๋ฅธ ์ฌ๋๊ณผ ๊ณต์ ํ๋ฉด ์ ๋ผ! ๐
Step 3: ํค ์ ์ฅ
์์ฑ๋ ํค๋ฅผ ์์ ํ ๊ณณ์ ๋ณต์ฌํด๋ฌ. ๋์ค์ ์ฝ๋์์ ์ฌ์ฉํ ๊ฑฐ์ผ.
๐๏ธ ๊ฐ๋ฐ ํ๊ฒฝ ์ธํ ํ๊ธฐ
์ด์ ์ค์ ๋ก ์ฝ๋ฉํ ํ๊ฒฝ์ ๋ง๋ค์ด๋ณด์. ํฐ๋ฏธ๋์ ์ด๊ณ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ฐ๋ผ์ค๋ฉด ๋ผ!
1๋จ๊ณ: ํ๋ก์ ํธ ํด๋ ์์ฑ
mkdir youtube-summarizer
cd youtube-summarizer
python -m venv venv
๊ฐ์ํ๊ฒฝ์ ๋ง๋๋ ์ด์ ๋ ํ๋ก์ ํธ๋ณ๋ก ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ ๋ฆฝ์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ์ํด์์ผ. ๋ค๋ฅธ ํ๋ก์ ํธ์ ์ถฉ๋์ด ์ ์๊ธฐ๊ฑฐ๋ ! ๐
2๋จ๊ณ: ๊ฐ์ํ๊ฒฝ ํ์ฑํ
Windows:
venv\Scripts\activate
Mac/Linux:
source venv/bin/activate
ํ์ฑํ๊ฐ ๋๋ฉด ํฐ๋ฏธ๋ ์์ (venv)๋ผ๋ ํ์๊ฐ ๋ํ๋ ๊ฑฐ์ผ. ์ด์ ์ค๋น ์๋ฃ! โจ
3๋จ๊ณ: ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
pip install google-generativeai youtube-transcript-api python-dotenv requests
์ค์น๊ฐ ๋๋๋ฉด requirements.txt ํ์ผ๋ ๋ง๋ค์ด๋๋ ๊ฒ ์ข์. ๋์ค์ ๋ค๋ฅธ ํ๊ฒฝ์์ ๋๊ฐ์ด ์ค์นํ ๋ ํธํ๊ฑฐ๋ !
pip freeze > requirements.txt
4๋จ๊ณ: ํ๊ฒฝ๋ณ์ ํ์ผ ์์ฑ
ํ๋ก์ ํธ ํด๋์ .env ํ์ผ์ ๋ง๋ค๊ณ ์๊น ๋ฐ์ API ํค๋ฅผ ๋ฃ์ด์ค:
GEMINI_API_KEY=your_api_key_here
YOUTUBE_API_KEY=your_youtube_api_key_here
YouTube API ํค๋ ์ ํ์ฌํญ์ด์ผ. ์์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ฌ ๋ ์ ์ฉํ์ง๋ง, ์์ด๋ ์๋ง ์ถ์ถ์ ๊ฐ๋ฅํด! ๐
๐ป ํต์ฌ ์ฝ๋ ์์ฑํ๊ธฐ
๋๋์ด ๋ณธ๊ฒฉ์ ์ธ ์ฝ๋ฉ ์๊ฐ์ด์ผ! ์ฐ๋ฆฌ๊ฐ ๋ง๋ค ๋ด์ ํฌ๊ฒ ์ธ ๊ฐ์ง ๊ธฐ๋ฅ์ผ๋ก ๊ตฌ์ฑ๋ผ:
1. ์ ํ๋ธ ์๋ง ์ถ์ถ 2. Gemini API๋ก ์์ฝ 3. ๊ฒฐ๊ณผ ํฌ๋งทํ ๋ฐ ์ถ๋ ฅ
๐ฆ ๋ชจ๋ 1: ์ ํ๋ธ ์๋ง ์ถ์ถ๊ธฐ
๋จผ์ ์ ํ๋ธ ์์์์ ์๋ง์ ๊ฐ์ ธ์ค๋ ๋ชจ๋์ ๋ง๋ค์ด๋ณด์. youtube_extractor.py ํ์ผ์ ์์ฑํ๊ณ ๋ค์ ์ฝ๋๋ฅผ ์์ฑํด:
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._errors import TranscriptsDisabled, NoTranscriptFound
import re
class YouTubeExtractor:
def __init__(self):
self.video_id = None
def extract_video_id(self, url):
"""
์ ํ๋ธ URL์์ ๋น๋์ค ID๋ฅผ ์ถ์ถํ๋ ํจ์
๋ค์ํ URL ํ์์ ์ง์ํด (youtu.be, youtube.com/watch ๋ฑ)
"""
patterns = [
r'(?:youtube\.com\/watch\?v=|youtu\.be\/)([^&\n?#]+)',
r'youtube\.com\/embed\/([^&\n?#]+)',
r'youtube\.com\/v\/([^&\n?#]+)'
]
for pattern in patterns:
match = re.search(pattern, url)
if match:
self.video_id = match.group(1)
return self.video_id
raise ValueError("์ ํจํ ์ ํ๋ธ URL์ด ์๋๋๋ค! ๐ข")
def get_transcript(self, url, languages=['ko', 'en']):
"""
์ ํ๋ธ ์์์ ์๋ง์ ๊ฐ์ ธ์ค๋ ํจ์
ํ๊ตญ์ด ์ฐ์ , ์์ผ๋ฉด ์์ด ์๋ง์ ์๋ํด
"""
try:
video_id = self.extract_video_id(url)
# ์๋ง ๊ฐ์ ธ์ค๊ธฐ ์๋
transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
# ์๋ ์๋ง ์ฐ์ ์๋
try:
transcript = transcript_list.find_manually_created_transcript(languages)
except:
# ์๋ ์๋ง์ด ์์ผ๋ฉด ์๋ ์์ฑ ์๋ง ์ฌ์ฉ
transcript = transcript_list.find_generated_transcript(languages)
# ์๋ง ํ
์คํธ ์ถ์ถ
transcript_data = transcript.fetch()
# ํ
์คํธ๋ง ์ถ์ถํด์ ํ๋๋ก ํฉ์น๊ธฐ
full_text = ' '.join([entry['text'] for entry in transcript_data])
return {
'success': True,
'video_id': video_id,
'text': full_text,
'language': transcript.language_code,
'is_generated': transcript.is_generated
}
except TranscriptsDisabled:
return {
'success': False,
'error': '์ด ์์์ ์๋ง์ด ๋นํ์ฑํ๋์ด ์์ด์! ๐'
}
except NoTranscriptFound:
return {
'success': False,
'error': f'์์ฒญํ ์ธ์ด({languages})์ ์๋ง์ ์ฐพ์ ์ ์์ด์! ๐'
}
except Exception as e:
return {
'success': False,
'error': f'์์์น ๋ชปํ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ด์: {str(e)} ๐ฑ'
}
์ด ์ฝ๋์ ํต์ฌ ํฌ์ธํธ๋ฅผ ์ค๋ช ํด์ค๊ฒ:
get_transcript ํจ์: ์๋ง์ ๊ฐ์ ธ์ฌ ๋ ์๋ ์๋ง์ ์ฐ์ ์ผ๋ก ์๋ํ๊ณ , ์์ผ๋ฉด ์๋ ์์ฑ ์๋ง์ ์ฌ์ฉํด. ์๋ํ๋ฉด ์๋ ์๋ง์ด ๋ณดํต ๋ ์ ํํ๊ฑฐ๋ ! ๊ทธ๋ฆฌ๊ณ ํ๊ตญ์ด๊ฐ ์์ผ๋ฉด ์์ด๋ก ํด๋ฐฑ(fallback)ํ๋๋ก ์ค๊ณํ์ด. ๐
๐ค ๋ชจ๋ 2: Gemini ์์ฝ ์์ง
์ด์ ์ถ์ถํ ์๋ง์ Gemini API๋ก ๋ณด๋ด์ ์์ฝํ๋ ๋ชจ๋์ ๋ง๋ค์ด๋ณด์. gemini_summarizer.py ํ์ผ์ ์์ฑํด:
import google.generativeai as genai
from typing import Dict, Optional
import os
from dotenv import load_dotenv
load_dotenv()
class GeminiSummarizer:
def __init__(self, api_key: Optional[str] = None):
"""
Gemini API ํด๋ผ์ด์ธํธ ์ด๊ธฐํ
api_key๋ฅผ ์ง์ ์ ๋ฌํ๊ฑฐ๋ ํ๊ฒฝ๋ณ์์์ ๊ฐ์ ธ์ฌ ์ ์์ด
"""
self.api_key = api_key or os.getenv('GEMINI_API_KEY')
if not self.api_key:
raise ValueError("API ํค๊ฐ ํ์ํด์! .env ํ์ผ์ ํ์ธํด์ฃผ์ธ์. ๐")
genai.configure(api_key=self.api_key)
# Gemini 1.5 Pro ๋ชจ๋ธ ์ฌ์ฉ (๊ธด ์ปจํ
์คํธ ์ฒ๋ฆฌ์ ์ต์ )
self.model = genai.GenerativeModel('gemini-1.5-pro-latest')
def create_summary_prompt(self, transcript: str, style: str = 'detailed') -> str:
"""
์์ฝ ์คํ์ผ์ ๋ฐ๋ผ ๋ค๋ฅธ ํ๋กฌํํธ๋ฅผ ์์ฑํด
"""
base_prompt = f"""
๋ค์์ ์ ํ๋ธ ์์์ ์๋ง ๋ด์ฉ์
๋๋ค. ์ด ๋ด์ฉ์ ๋ถ์ํ๊ณ ์์ฝํด์ฃผ์ธ์.
์๋ง ๋ด์ฉ:
{transcript}
"""
style_prompts = {
'detailed': """
์์ธํ ์์ฝ์ ์์ฑํด์ฃผ์ธ์:
1. ์์์ ์ฃผ์ ์ ๋ชฉ์ (2-3๋ฌธ์ฅ)
2. ํต์ฌ ๋ด์ฉ์ 5-7๊ฐ์ ์ฃผ์ ํฌ์ธํธ๋ก ์ ๋ฆฌ
3. ๊ฐ ํฌ์ธํธ๋ง๋ค ๊ตฌ์ฒด์ ์ธ ์ค๋ช
ํฌํจ
4. ๊ฒฐ๋ก ๋ฐ ์์ฌ์
์ด๋ชจ์ง๋ฅผ ์ ์ ํ ์ฌ์ฉํด์ ๊ฐ๋
์ฑ์ ๋์ฌ์ฃผ์ธ์! โจ
""",
'brief': """
๊ฐ๋จ ์์ฝ์ ์์ฑํด์ฃผ์ธ์:
1. ํ ๋ฌธ์ฅ์ผ๋ก ์์์ ํต์ฌ ์ฃผ์
2. 3-4๊ฐ์ ์ฃผ์ ํฌ์ธํธ (๊ฐ๊ฐ ํ ๋ฌธ์ฅ)
3. ํ ๋ฌธ์ฅ์ผ๋ก ๊ฒฐ๋ก
๊ฐ๊ฒฐํ๊ณ ๋ช
ํํ๊ฒ ์์ฑํด์ฃผ์ธ์! ๐
""",
'bullet': """
๋ถ๋ฆฟ ํฌ์ธํธ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
โข ์์ ์ฃผ์
โข ์ฃผ์ ๋ด์ฉ (5-8๊ฐ ํญ๋ชฉ)
โข ํต์ฌ ๋ฉ์์ง
๊ฐ ํญ๋ชฉ์ ํ ์ค๋ก ๊ฐ๋จ๋ช
๋ฃํ๊ฒ! ๐ฏ
""",
'technical': """
๊ธฐ์ ์ ๊ด์ ์์ ์์ฝํด์ฃผ์ธ์:
1. ๋ค๋ฃจ๋ ๊ธฐ์ /๊ฐ๋
2. ์ฃผ์ ๊ธฐ์ ์คํ ๋ฐ ๋๊ตฌ
3. ๊ตฌํ ๋ฐฉ๋ฒ ๋ฐ ์ ์ฐจ
4. ์ฅ๋จ์ ๋ถ์
5. ์ค์ฉ์ ์ ์ฉ ๋ฐฉ์
๊ฐ๋ฐ์ ๊ด์ ์์ ์์ธํ๊ฒ ์์ฑํด์ฃผ์ธ์! ๐ป
"""
}
return base_prompt + style_prompts.get(style, style_prompts['detailed'])
def summarize(self, transcript: str, style: str = 'detailed',
max_length: Optional[int] = None) -> Dict:
"""
์๋ง์ ์์ฝํ๋ ๋ฉ์ธ ํจ์
"""
try:
# ํ๋กฌํํธ ์์ฑ
prompt = self.create_summary_prompt(transcript, style)
# ์์ฑ ์ค์
generation_config = {
'temperature': 0.7, # ์ฐฝ์์ฑ ์กฐ์ (0~1)
'top_p': 0.8,
'top_k': 40,
'max_output_tokens': max_length or 2048,
}
# Gemini API ํธ์ถ
response = self.model.generate_content(
prompt,
generation_config=generation_config
)
# ์์ ์ฑ ํํฐ๋ง ์ฒดํฌ
if response.prompt_feedback.block_reason:
return {
'success': False,
'error': f'์ฝํ
์ธ ๊ฐ ์์ ์ฑ ํํฐ์ ๊ฑธ๋ ธ์ด์: {response.prompt_feedback.block_reason} ๐ซ'
}
return {
'success': True,
'summary': response.text,
'style': style,
'model': 'gemini-1.5-pro-latest'
}
except Exception as e:
return {
'success': False,
'error': f'์์ฝ ์์ฑ ์ค ์ค๋ฅ ๋ฐ์: {str(e)} ๐ข'
}
def summarize_with_questions(self, transcript: str) -> Dict:
"""
์์ฝ๊ณผ ํจ๊ป ์ดํด๋ ์ฒดํฌ ์ง๋ฌธ๋ ์์ฑํด์ฃผ๋ ํจ์
"""
prompt = f"""
๋ค์ ์ ํ๋ธ ์์ ์๋ง์ ๋ถ์ํ๊ณ :
{transcript}
1. ์์ธํ ์์ฝ ์์ฑ
2. ๋ด์ฉ ์ดํด๋๋ฅผ ์ฒดํฌํ ์ ์๋ ์ง๋ฌธ 3-5๊ฐ ์์ฑ
3. ๊ฐ ์ง๋ฌธ์ ๋ต๋ณ ์ ์
ํ์ต ์๋ฃ๋ก ํ์ฉํ ์ ์๋๋ก ๊ตฌ์ฑํด์ฃผ์ธ์! ๐
"""
try:
response = self.model.generate_content(prompt)
return {
'success': True,
'content': response.text,
'type': 'summary_with_questions'
}
except Exception as e:
return {
'success': False,
'error': str(e)
}
์ด ์ฝ๋์์ ์ฃผ๋ชฉํด์ผ ํ ๋ถ๋ถ๋ค์ ์ง์ด๋ณผ๊ฒ:
๐ ํต์ฌ ๊ธฐ๋ฅ ์ค๋ช
๋ค์ํ ์์ฝ ์คํ์ผ ์ง์
'detailed', 'brief', 'bullet', 'technical' ๋ค ๊ฐ์ง ์คํ์ผ์ ์ ๊ณตํด. ์ฌ์ฉ์๊ฐ ์ํ๋ ํํ๋ก ์์ฝ์ ๋ฐ์ ์ ์์ด์ ํ์ฉ๋๊ฐ ๋์! ์๋ฅผ ๋ค์ด, ๋น ๋ฅด๊ฒ ํ์ด๋ณด๊ณ ์ถ์ผ๋ฉด 'brief', ๊ธฐ์ ๋ธ๋ก๊ทธ ์์ฑํ ๋๋ 'technical' ์คํ์ผ์ ์ ํํ๋ฉด ๋ผ. ๐จ
Generation Config ์ต์ ํ
temperature๋ 0.7๋ก ์ค์ ํ์ด. ์ด๊ฒ ๋ญ๋๋ฉด, ๋๋ฌด ๋ฎ์ผ๋ฉด ํญ์ ๋น์ทํ ๋ต๋ณ๋ง ๋์ค๊ณ , ๋๋ฌด ๋์ผ๋ฉด ์๋ฑํ ๋ต๋ณ์ด ๋์ฌ ์ ์๊ฑฐ๋ . 0.7์ ์ฐฝ์์ฑ๊ณผ ์ผ๊ด์ฑ์ ๊ท ํ์ ์ด์ผ! โ๏ธ
์์ ์ฑ ํํฐ๋ง
Gemini๋ ์ ํดํ ์ฝํ
์ธ ๋ฅผ ์๋์ผ๋ก ํํฐ๋งํด. ๋ง์ฝ ์์ ๋ด์ฉ์ด ๋ถ์ ์ ํ๋ค๊ณ ํ๋จ๋๋ฉด block_reason์ ๋ฐํํ๋๋ฐ, ์ด๊ฑธ ์ฒดํฌํด์ ์ฌ์ฉ์์๊ฒ ์๋ ค์ค์ผ ํด. ๐ก๏ธ
์๋ฌ ํธ๋ค๋ง
๋ชจ๋ ํจ์๊ฐ ๋์
๋๋ฆฌ ํํ๋ก ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋๋ก ํ์ด. success ํค๋ก ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ํ์ธํ๊ณ , ์คํจํ๋ฉด error ๋ฉ์์ง๋ฅผ ํฌํจํด. ์ด๋ ๊ฒ ํ๋ฉด ๋์ค์ ํ๋ก ํธ์๋์ ์ฐ๋ํ ๋ ํจ์ฌ ํธํด! ๐ฏ
๐จ ๋ชจ๋ 3: ๋ฉ์ธ ์ ํ๋ฆฌ์ผ์ด์
์ด์ ๋ชจ๋ ๊ฑธ ํตํฉํ๋ ๋ฉ์ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค์ด๋ณด์. main.py ํ์ผ์ ์์ฑํด:
from youtube_extractor import YouTubeExtractor
from gemini_summarizer import GeminiSummarizer
import argparse
import json
from datetime import datetime
class YouTubeSummarizerBot:
def __init__(self):
self.extractor = YouTubeExtractor()
self.summarizer = GeminiSummarizer()
def process_video(self, url: str, style: str = 'detailed',
save_output: bool = True) -> dict:
"""
์ ํ๋ธ ์์์ ์ฒ๋ฆฌํ๋ ๋ฉ์ธ ํจ์
"""
print("๐ฌ ์ ํ๋ธ ์์ ์ฒ๋ฆฌ๋ฅผ ์์ํฉ๋๋ค...\n")
# 1๋จ๊ณ: ์๋ง ์ถ์ถ
print("๐ ์๋ง์ ์ถ์ถํ๋ ์ค...")
transcript_result = self.extractor.get_transcript(url)
if not transcript_result['success']:
print(f"โ ์๋ง ์ถ์ถ ์คํจ: {transcript_result['error']}")
return transcript_result
print(f"โ
์๋ง ์ถ์ถ ์๋ฃ! (์ธ์ด: {transcript_result['language']})")
print(f" ์๋ง ๊ธธ์ด: {len(transcript_result['text'])} ๊ธ์\n")
# 2๋จ๊ณ: ์์ฝ ์์ฑ
print(f"๐ค Gemini AI๋ก ์์ฝ ์์ฑ ์ค... (์คํ์ผ: {style})")
summary_result = self.summarizer.summarize(
transcript_result['text'],
style=style
)
if not summary_result['success']:
print(f"โ ์์ฝ ์์ฑ ์คํจ: {summary_result['error']}")
return summary_result
print("โ
์์ฝ ์์ฑ ์๋ฃ!\n")
# ๊ฒฐ๊ณผ ํตํฉ
result = {
'success': True,
'video_id': transcript_result['video_id'],
'url': url,
'transcript_language': transcript_result['language'],
'summary_style': style,
'summary': summary_result['summary'],
'timestamp': datetime.now().isoformat()
}
# 3๋จ๊ณ: ๊ฒฐ๊ณผ ์ถ๋ ฅ
self.print_summary(result)
# 4๋จ๊ณ: ํ์ผ ์ ์ฅ (์ต์
)
if save_output:
filename = self.save_to_file(result)
print(f"\n๐พ ๊ฒฐ๊ณผ๊ฐ ์ ์ฅ๋์์ต๋๋ค: {filename}")
return result
def print_summary(self, result: dict):
"""
์์ฝ ๊ฒฐ๊ณผ๋ฅผ ์์๊ฒ ์ถ๋ ฅํ๋ ํจ์
"""
print("=" * 80)
print("๐ ์์ฝ ๊ฒฐ๊ณผ")
print("=" * 80)
print(f"\n๐ฅ ๋น๋์ค ID: {result['video_id']}")
print(f"๐ URL: {result['url']}")
print(f"๐ฃ๏ธ ์๋ง ์ธ์ด: {result['transcript_language']}")
print(f"๐ ์์ฝ ์คํ์ผ: {result['summary_style']}")
print(f"โฐ ์์ฑ ์๊ฐ: {result['timestamp']}")
print("\n" + "=" * 80)
print("๐ ์์ฝ ๋ด์ฉ")
print("=" * 80)
print(f"\n{result['summary']}\n")
print("=" * 80)
def save_to_file(self, result: dict) -> str:
"""
๊ฒฐ๊ณผ๋ฅผ JSON ํ์ผ๋ก ์ ์ฅ
"""
filename = f"summary_{result['video_id']}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
with open(filename, 'w', encoding='utf-8') as f:
json.dump(result, f, ensure_ascii=False, indent=2)
return filename
def batch_process(self, urls: list, style: str = 'detailed'):
"""
์ฌ๋ฌ ์์์ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ ํจ์
"""
results = []
total = len(urls)
print(f"๐ ์ด {total}๊ฐ์ ์์์ ์ฒ๋ฆฌํฉ๋๋ค!\n")
for idx, url in enumerate(urls, 1):
print(f"\n{'='*80}")
print(f"์งํ ์ํฉ: {idx}/{total}")
print(f"{'='*80}\n")
result = self.process_video(url, style, save_output=True)
results.append(result)
if idx < total:
print("\nโณ ๋ค์ ์์ ์ฒ๋ฆฌ๊น์ง 3์ด ๋๊ธฐ...\n")
import time
time.sleep(3) # API ๋ ์ดํธ ๋ฆฌ๋ฐ ๊ณ ๋ ค
print(f"\n๐ ๋ชจ๋ ์์ ์ฒ๋ฆฌ ์๋ฃ! ์ด {total}๊ฐ")
return results
def main():
"""
์ปค๋งจ๋๋ผ์ธ ์ธํฐํ์ด์ค
"""
parser = argparse.ArgumentParser(
description='๐ค Gemini API๋ฅผ ํ์ฉํ ์ ํ๋ธ ์์ ์๋์์ฝ ๋ด'
)
parser.add_argument(
'url',
help='์์ฝํ ์ ํ๋ธ ์์ URL'
)
parser.add_argument(
'--style',
choices=['detailed', 'brief', 'bullet', 'technical'],
default='detailed',
help='์์ฝ ์คํ์ผ ์ ํ (๊ธฐ๋ณธ๊ฐ: detailed)'
)
parser.add_argument(
'--no-save',
action='store_true',
help='๊ฒฐ๊ณผ๋ฅผ ํ์ผ๋ก ์ ์ฅํ์ง ์์'
)
args = parser.parse_args()
# ๋ด ์คํ
bot = YouTubeSummarizerBot()
bot.process_video(
args.url,
style=args.style,
save_output=not args.no_save
)
if __name__ == '__main__':
main()
์ด์ ์์ฑ์ด์ผ! ์ด ๋ฉ์ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ชจ๋ ๊ธฐ๋ฅ์ ํตํฉํ๊ณ , ์ฌ์ฉ์ ์นํ์ ์ธ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํด. ๐
๐ ์คํํ๊ณ ํ ์คํธํ๊ธฐ
์, ์ด์ ์ฐ๋ฆฌ๊ฐ ๋ง๋ ๋ด์ ์ค์ ๋ก ๋๋ ค๋ณผ ์๊ฐ์ด์ผ! ํฐ๋ฏธ๋์์ ๋ค์ ๋ช ๋ น์ด๋ฅผ ์ ๋ ฅํด๋ด:
๊ธฐ๋ณธ ์คํ
python main.py "https://www.youtube.com/watch?v=VIDEO_ID"
VIDEO_ID ๋ถ๋ถ์ ์ค์ ์ ํ๋ธ ์์ ID๋ฅผ ๋ฃ์ผ๋ฉด ๋ผ. ์๋ฅผ ๋ค์ด:
python main.py "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
์์ฝ ์คํ์ผ ์ง์
python main.py "https://youtu.be/VIDEO_ID" --style brief
๊ฐ๋จํ ์์ฝ์ด ํ์ํ๋ฉด brief, ๊ธฐ์ ์ ์ธ ๋ด์ฉ์ด๋ฉด technical ์คํ์ผ์ ์ ํํด! ๐จ
ํ์ผ ์ ์ฅ ์ ํ๊ธฐ
python main.py "https://youtu.be/VIDEO_ID" --no-save
๊ฒฐ๊ณผ๋ฅผ ํ๋ฉด์ผ๋ก๋ง ๋ณด๊ณ ์ถ์ ๋ ์ฌ์ฉํด. ํ์ผ์ด ์์ด๋ ๊ฒ ์ซ๋ค๋ฉด ์ด ์ต์ ์ ์จ! ๐
๐ก ์ค์ ํ ์คํธ ํ
1. ์งง์ ์์๋ถํฐ ์์
์ฒ์์ 5-10๋ถ์ง๋ฆฌ ์์์ผ๋ก ํ
์คํธํด๋ด. ๊ธด ์์์ ์ฒ๋ฆฌ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๊ฑฐ๋ ! โฑ๏ธ
2. ๋ค์ํ ์ธ์ด ํ
์คํธ
ํ๊ตญ์ด ์์, ์์ด ์์ ๋ ๋ค ํ
์คํธํด๋ณด๋ฉด ์ข์. ์๋ง ์ถ์ถ์ด ์ธ์ด๋ณ๋ก ๋ค๋ฅด๊ฒ ์๋ํ ์ ์์ด.
3. ์๋ง์ด ์๋ ์์ ๋๋น
์๋ง์ด ์๋ ์์์ ๋ฃ์ผ๋ฉด ์ด๋ป๊ฒ ๋๋์ง๋ ํ์ธํด๋ด. ์๋ฌ ํธ๋ค๋ง์ด ์ ๋๋ก ์๋ํ๋์ง ์ฒดํฌํ๋ ๊ฑฐ์ง! ๐ก๏ธ
4. API ํ ๋น๋ ์ฒดํฌ
Gemini API ๋ฌด๋ฃ ํฐ์ด๋ ๋ถ๋น ์์ฒญ ์ ํ์ด ์์ด. ๋๋ฌด ๋ง์ ์์์ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ฉด ์๋ฌ๊ฐ ๋ ์ ์์ผ๋ ์ฃผ์ํด! ๐
๐ฌ ์ ํ๋ธ ์์ ์ฒ๋ฆฌ๋ฅผ ์์ํฉ๋๋ค...
๐ ์๋ง์ ์ถ์ถํ๋ ์ค...
โ ์๋ง ์ถ์ถ ์๋ฃ! (์ธ์ด: ko)
์๋ง ๊ธธ์ด: 15,234 ๊ธ์
๐ค Gemini AI๋ก ์์ฝ ์์ฑ ์ค... (์คํ์ผ: detailed)
โ ์์ฝ ์์ฑ ์๋ฃ!
๊ทธ๋ฆฌ๊ณ ๋์ ์์๊ฒ ํฌ๋งท๋ ์์ฝ ๊ฒฐ๊ณผ๊ฐ ๋ํ๋! ๐
โก ์ฑ๋ฅ ์ต์ ํ ๋ฐ ๊ณ ๊ธ ๊ธฐ๋ฅ
๊ธฐ๋ณธ ๋ด์ ์์ฑํ์ง๋ง, ์ค์ ์๋น์ค๋ก ์ด์ํ๋ ค๋ฉด ๋ช ๊ฐ์ง ๊ฐ์ ์ด ํ์ํด. ์ฑ๋ฅ์ ๋์ด๊ณ ๋ ๋ง์ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์! ๐
1๏ธโฃ ์บ์ฑ ์์คํ ๊ตฌ์ถ
๊ฐ์ ์์์ ์ฌ๋ฌ ๋ฒ ์์ฝํ๋ฉด ๋นํจ์จ์ ์ด์์? ์บ์ฑ์ ์ถ๊ฐํด์ ์ด๋ฏธ ์ฒ๋ฆฌํ ์์์ ์ ์ฅ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋ก ๋ฐํํ๋๋ก ๋ง๋ค์ด๋ณด์.
import json
import hashlib
from pathlib import Path
from datetime import datetime, timedelta
from typing import Optional, Dict
class CacheManager:
def __init__(self, cache_dir: str = 'cache', expire_days: int = 7):
"""
์บ์ ๋งค๋์ ์ด๊ธฐํ
cache_dir: ์บ์ ํ์ผ์ ์ ์ฅํ ๋๋ ํ ๋ฆฌ
expire_days: ์บ์ ๋ง๋ฃ ๊ธฐ๊ฐ (์ผ)
"""
self.cache_dir = Path(cache_dir)
self.cache_dir.mkdir(exist_ok=True)
self.expire_days = expire_days
def _get_cache_key(self, video_id: str, style: str) -> str:
"""
๋น๋์ค ID์ ์คํ์ผ๋ก ๊ณ ์ ํ ์บ์ ํค ์์ฑ
"""
key_string = f"{video_id}_{style}"
return hashlib.md5(key_string.encode()).hexdigest()
def _get_cache_path(self, cache_key: str) -> Path:
"""
์บ์ ํ์ผ ๊ฒฝ๋ก ๋ฐํ
"""
return self.cache_dir / f"{cache_key}.json"
def get(self, video_id: str, style: str) -> Optional[Dict]:
"""
์บ์์์ ๊ฒฐ๊ณผ ๊ฐ์ ธ์ค๊ธฐ
"""
cache_key = self._get_cache_key(video_id, style)
cache_path = self._get_cache_path(cache_key)
if not cache_path.exists():
return None
try:
with open(cache_path, 'r', encoding='utf-8') as f:
cached_data = json.load(f)
# ์บ์ ๋ง๋ฃ ์ฒดํฌ
cached_time = datetime.fromisoformat(cached_data['cached_at'])
if datetime.now() - cached_time > timedelta(days=self.expire_days):
cache_path.unlink() # ๋ง๋ฃ๋ ์บ์ ์ญ์
return None
print(f"๐พ ์บ์์์ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์์ด์! (์์ฑ์ผ: {cached_time.strftime('%Y-%m-%d %H:%M')})")
return cached_data['result']
except Exception as e:
print(f"โ ๏ธ ์บ์ ์ฝ๊ธฐ ์คํจ: {e}")
return None
def set(self, video_id: str, style: str, result: Dict):
"""
๊ฒฐ๊ณผ๋ฅผ ์บ์์ ์ ์ฅ
"""
cache_key = self._get_cache_key(video_id, style)
cache_path = self._get_cache_path(cache_key)
cache_data = {
'video_id': video_id,
'style': style,
'cached_at': datetime.now().isoformat(),
'result': result
}
try:
with open(cache_path, 'w', encoding='utf-8') as f:
json.dump(cache_data, f, ensure_ascii=False, indent=2)
print("๐พ ๊ฒฐ๊ณผ๋ฅผ ์บ์์ ์ ์ฅํ์ด์!")
except Exception as e:
print(f"โ ๏ธ ์บ์ ์ ์ฅ ์คํจ: {e}")
def clear_expired(self):
"""
๋ง๋ฃ๋ ์บ์ ํ์ผ๋ค์ ๋ชจ๋ ์ญ์
"""
deleted_count = 0
for cache_file in self.cache_dir.glob('*.json'):
try:
with open(cache_file, 'r', encoding='utf-8') as f:
cached_data = json.load(f)
cached_time = datetime.fromisoformat(cached_data['cached_at'])
if datetime.now() - cached_time > timedelta(days=self.expire_days):
cache_file.unlink()
deleted_count += 1
except:
continue
print(f"๐๏ธ {deleted_count}๊ฐ์ ๋ง๋ฃ๋ ์บ์๋ฅผ ์ญ์ ํ์ด์!")
return deleted_count
์ด์ main.py์ YouTubeSummarizerBot ํด๋์ค์ ์บ์ ๋งค๋์ ๋ฅผ ํตํฉํด๋ณด์:
class YouTubeSummarizerBot:
def __init__(self, use_cache: bool = True):
self.extractor = YouTubeExtractor()
self.summarizer = GeminiSummarizer()
self.cache = CacheManager() if use_cache else None
def process_video(self, url: str, style: str = 'detailed',
save_output: bool = True, use_cache: bool = True) -> dict:
"""
์ ํ๋ธ ์์์ ์ฒ๋ฆฌํ๋ ๋ฉ์ธ ํจ์ (์บ์ฑ ์ถ๊ฐ)
"""
print("๐ฌ ์ ํ๋ธ ์์ ์ฒ๋ฆฌ๋ฅผ ์์ํฉ๋๋ค...\n")
# ๋น๋์ค ID ์ถ์ถ
video_id = self.extractor.extract_video_id(url)
# ์บ์ ์ฒดํฌ
if use_cache and self.cache:
cached_result = self.cache.get(video_id, style)
if cached_result:
self.print_summary(cached_result)
return cached_result
# ... ๊ธฐ์กด ์ฒ๋ฆฌ ๋ก์ง ...
# ์บ์์ ์ ์ฅ
if use_cache and self.cache:
self.cache.set(video_id, style, result)
return result
์๋ต ์๋ ํฅ์: ์บ์๋ ๊ฒฐ๊ณผ๋ ์ฆ์ ๋ฐํ๋๋๊น ์ฌ์ฉ์ ๊ฒฝํ์ด ํจ์ฌ ์ข์์ ธ. โก
API ๋ ์ดํธ ๋ฆฌ๋ฐ ํํผ: ๊ฐ์ ์์์ ๋ฐ๋ณต ์์ฒญํด๋ API ํ ๋น๋์ ์๋นํ์ง ์์! ๐ฏ
2๏ธโฃ ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ก ์ฑ๋ฅ ๊ฐ์
์ฌ๋ฌ ์์์ ๋์์ ์ฒ๋ฆฌํ๊ณ ์ถ๋ค๋ฉด? asyncio๋ฅผ ์ฌ์ฉํด์ ๋น๋๊ธฐ๋ก ๋ง๋ค์ด๋ณด์!
import asyncio
from typing import List, Dict
import aiohttp
from youtube_extractor import YouTubeExtractor
from gemini_summarizer import GeminiSummarizer
class AsyncYouTubeSummarizer:
def __init__(self, max_concurrent: int = 3):
"""
๋น๋๊ธฐ ์์ฝ๊ธฐ ์ด๊ธฐํ
max_concurrent: ๋์์ ์ฒ๋ฆฌํ ์ต๋ ์์ ์
"""
self.extractor = YouTubeExtractor()
self.summarizer = GeminiSummarizer()
self.semaphore = asyncio.Semaphore(max_concurrent)
async def process_single_video(self, url: str, style: str = 'detailed') -> Dict:
"""
๋จ์ผ ์์์ ๋น๋๊ธฐ๋ก ์ฒ๋ฆฌ
"""
async with self.semaphore:
print(f"๐ฌ ์ฒ๋ฆฌ ์์: {url}")
# ์๋ง ์ถ์ถ (๋๊ธฐ ํจ์๋ฅผ ๋น๋๊ธฐ๋ก ์คํ)
loop = asyncio.get_event_loop()
transcript_result = await loop.run_in_executor(
None,
self.extractor.get_transcript,
url
)
if not transcript_result['success']:
return transcript_result
# ์์ฝ ์์ฑ
summary_result = await loop.run_in_executor(
None,
self.summarizer.summarize,
transcript_result['text'],
style
)
if not summary_result['success']:
return summary_result
print(f"โ
์ฒ๋ฆฌ ์๋ฃ: {url}")
return {
'success': True,
'url': url,
'video_id': transcript_result['video_id'],
'summary': summary_result['summary']
}
async def process_multiple_videos(self, urls: List[str],
style: str = 'detailed') -> List[Dict]:
"""
์ฌ๋ฌ ์์์ ๋์์ ์ฒ๋ฆฌ
"""
tasks = [self.process_single_video(url, style) for url in urls]
results = await asyncio.gather(*tasks, return_exceptions=True)
# ์์ธ ์ฒ๋ฆฌ
processed_results = []
for result in results:
if isinstance(result, Exception):
processed_results.append({
'success': False,
'error': str(result)
})
else:
processed_results.append(result)
return processed_results
# ์ฌ์ฉ ์์
async def main():
urls = [
"https://www.youtube.com/watch?v=VIDEO_ID_1",
"https://www.youtube.com/watch?v=VIDEO_ID_2",
"https://www.youtube.com/watch?v=VIDEO_ID_3"
]
summarizer = AsyncYouTubeSummarizer(max_concurrent=2)
results = await summarizer.process_multiple_videos(urls, style='brief')
for idx, result in enumerate(results, 1):
print(f"\n{'='*80}")
print(f"์์ {idx} ๊ฒฐ๊ณผ:")
print(f"{'='*80}")
if result['success']:
print(result['summary'])
else:
print(f"์ค๋ฅ: {result['error']}")
if __name__ == '__main__':
asyncio.run(main())
๋น๋๊ธฐ ์ฒ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด 3๊ฐ์ ์์์ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ ๋ 90์ด ๊ฑธ๋ฆฌ๋ ๊ฒ, ๋์์ ์ฒ๋ฆฌํ๋ฉด 30์ด๋ก ์ค์ด๋ค ์ ์์ด! ์๊ฐ์ด 3๋ฐฐ๋ ์ ์ฝ๋๋ ๊ฑฐ์ง. โก
3๏ธโฃ ์น ์ธํฐํ์ด์ค ์ถ๊ฐํ๊ธฐ
์ปค๋งจ๋๋ผ์ธ๋ ์ข์ง๋ง, ์น ์ธํฐํ์ด์ค๊ฐ ์์ผ๋ฉด ํจ์ฌ ์ฌ์ฉํ๊ธฐ ํธํ์์? Flask๋ก ๊ฐ๋จํ ์น ์ฑ์ ๋ง๋ค์ด๋ณด์!
from flask import Flask, render_template, request, jsonify
from youtube_extractor import YouTubeExtractor
from gemini_summarizer import GeminiSummarizer
from cache_manager import CacheManager
import os
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(24)
# ์ ์ญ ์ธ์คํด์ค
extractor = YouTubeExtractor()
summarizer = GeminiSummarizer()
cache = CacheManager()
@app.route('/')
def index():
"""
๋ฉ์ธ ํ์ด์ง
"""
return render_template('index.html')
@app.route('/api/summarize', methods=['POST'])
def summarize():
"""
์์ฝ API ์๋ํฌ์ธํธ
"""
try:
data = request.get_json()
url = data.get('url')
style = data.get('style', 'detailed')
use_cache = data.get('use_cache', True)
if not url:
return jsonify({
'success': False,
'error': 'URL์ด ํ์ํฉ๋๋ค!'
}), 400
# ๋น๋์ค ID ์ถ์ถ
video_id = extractor.extract_video_id(url)
# ์บ์ ์ฒดํฌ
if use_cache:
cached_result = cache.get(video_id, style)
if cached_result:
return jsonify({
'success': True,
'from_cache': True,
'result': cached_result
})
# ์๋ง ์ถ์ถ
transcript_result = extractor.get_transcript(url)
if not transcript_result['success']:
return jsonify(transcript_result), 400
# ์์ฝ ์์ฑ
summary_result = summarizer.summarize(
transcript_result['text'],
style=style
)
if not summary_result['success']:
return jsonify(summary_result), 500
result = {
'video_id': video_id,
'url': url,
'summary': summary_result['summary'],
'style': style,
'language': transcript_result['language']
}
# ์บ์์ ์ ์ฅ
if use_cache:
cache.set(video_id, style, result)
return jsonify({
'success': True,
'from_cache': False,
'result': result
})
except Exception as e:
return jsonify({
'success': False,
'error': str(e)
}), 500
@app.route('/api/styles', methods=['GET'])
def get_styles():
"""
์ฌ์ฉ ๊ฐ๋ฅํ ์์ฝ ์คํ์ผ ๋ชฉ๋ก ๋ฐํ
"""
styles = {
'detailed': '์์ธ ์์ฝ - ํต์ฌ ๋ด์ฉ์ ์์ธํ๊ฒ',
'brief': '๊ฐ๋จ ์์ฝ - ํต์ฌ๋ง ๋น ๋ฅด๊ฒ',
'bullet': '๋ถ๋ฆฟ ํฌ์ธํธ - ํญ๋ชฉ๋ณ๋ก ์ ๋ฆฌ',
'technical': '๊ธฐ์ ์์ฝ - ๊ฐ๋ฐ์ ๊ด์ '
}
return jsonify(styles)
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0', port=5000)
๊ทธ๋ฆฌ๊ณ ๊ฐ๋จํ HTML ํ ํ๋ฆฟ๋ ๋ง๋ค์ด์ค์ผ ํด. templates/index.html ํ์ผ์ ์์ฑํ์:
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>์ ํ๋ธ ์์ ์๋์์ฝ ๋ด</title>
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body { font-family: 'Segoe UI', sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; padding: 20px; }
.container { max-width: 800px; margin: 0 auto; background: white; border-radius: 20px; padding: 40px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); }
h1 { color: #667eea; margin-bottom: 30px; text-align: center; }
.input-group { margin-bottom: 20px; }
label { display: block; margin-bottom: 8px; font-weight: 600; color: #333; }
input[type="text"], select { width: 100%; padding: 12px; border: 2px solid #e0e0e0; border-radius: 8px; font-size: 16px; }
input[type="text"]:focus, select:focus { outline: none; border-color: #667eea; }
button { width: 100%; padding: 15px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; border-radius: 8px; font-size: 18px; font-weight: 600; cursor: pointer; transition: transform 0.2s; }
button:hover { transform: translateY(-2px); }
button:disabled { opacity: 0.6; cursor: not-allowed; }
.result { margin-top: 30px; padding: 20px; background: #f8f9fa; border-radius: 12px; display: none; }
.result.show { display: block; }
.loading { text-align: center; padding: 20px; display: none; }
.loading.show { display: block; }
.error { background: #fee; color: #c00; padding: 15px; border-radius: 8px; margin-top: 20px; display: none; }
.error.show { display: block; }
</style>
</head>
<body>
<div class="container">
<h1>๐ค ์ ํ๋ธ ์์ ์๋์์ฝ ๋ด</h1>
<div class="input-group">
<label for="url">์ ํ๋ธ URL</label>
<input type="text" id="url" placeholder="https://www.youtube.com/watch?v=...">
</div>
<div class="input-group">
<label for="style">์์ฝ ์คํ์ผ</label>
<select id="style">
<option value="detailed">์์ธ ์์ฝ</option>
<option value="brief">๊ฐ๋จ ์์ฝ</option>
<option value="bullet">๋ถ๋ฆฟ ํฌ์ธํธ</option>
<option value="technical">๊ธฐ์ ์์ฝ</option>
</select>
</div>
<button id="summarizeBtn" onclick="summarize()">์์ฝ ์์ฑํ๊ธฐ โจ</button>
<div class="loading" id="loading">
<p>โณ ์์ฝ์ ์์ฑํ๋ ์ค์
๋๋ค...</p>
</div>
<div class="error" id="error"></div>
<div class="result" id="result">
<h3>๐ ์์ฝ ๊ฒฐ๊ณผ</h3>
<div id="summaryContent"></div>
</div>
</div>
<script>
async function summarize() {
const url = document.getElementById('url').value;
const style = document.getElementById('style').value;
const btn = document.getElementById('summarizeBtn');
const loading = document.getElementById('loading');
const result = document.getElementById('result');
const error = document.getElementById('error');
if (!url) {
showError('URL์ ์
๋ ฅํด์ฃผ์ธ์!');
return;
}
btn.disabled = true;
loading.classList.add('show');
result.classList.remove('show');
error.classList.remove('show');
try {
const response = await fetch('/api/summarize', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ url, style, use_cache: true })
});
const data = await response.json();
if (data.success) {
document.getElementById('summaryContent').innerHTML =
data.result.summary.replace(/\n/g, '<br>');
result.classList.add('show');
if (data.from_cache) {
showError('๐พ ์บ์์์ ๊ฐ์ ธ์จ ๊ฒฐ๊ณผ์
๋๋ค!');
}
} else {
showError(data.error);
}
} catch (e) {
showError('์ค๋ฅ๊ฐ ๋ฐ์ํ์ต๋๋ค: ' + e.message);
} finally {
btn.disabled = false;
loading.classList.remove('show');
}
}
function showError(message) {
const error = document.getElementById('error');
error.textContent = message;
error.classList.add('show');
}
</script>
</body>
</html>
์ด์ ์น ์๋ฒ๋ฅผ ์คํํ๋ฉด:
python web_app.py
๋ธ๋ผ์ฐ์ ์์ http://localhost:5000 ์ผ๋ก ์ ์ํ๋ฉด ์์ ์น ์ธํฐํ์ด์ค๋ฅผ ๋ณผ ์ ์์ด! ๐จ
๐ง ์ค์ ๋ฐฐํฌ ๊ฐ์ด๋
๋ก์ปฌ์์ ์ ์๋ํ๋ ๊ฑธ ํ์ธํ๋ค๋ฉด, ์ด์ ์ค์ ๋ก ์๋น์ค๋ฅผ ๋ฐฐํฌํด๋ณผ ์ฐจ๋ก์ผ! ์ฌ๋ฌ ๋ฐฐํฌ ์ต์ ์ด ์๋๋ฐ, ๊ฐ๊ฐ์ ์ฅ๋จ์ ์ ์์๋ณด์. ๐
์ต์ 1: Heroku๋ก ๋ฐฐํฌํ๊ธฐ
์ฅ์ :
โ
๋ฌด๋ฃ ํฐ์ด ์ ๊ณต (์ ํ์ ์ด์ง๋ง ํ
์คํธ์ฉ์ผ๋ก ์ถฉ๋ถ)
โ
Git ๊ธฐ๋ฐ ๋ฐฐํฌ๋ก ๊ฐํธํจ
โ
์๋ HTTPS ์ง์
๋จ์ :
โ ๋ฌด๋ฃ ํฐ์ด๋ 30๋ถ ๋นํ์ฑ ์ ์ฌ๋ฆฝ ๋ชจ๋
โ ์ ๋ฃ ์ ํ ์ ๋น์ฉ์ด ๋ค์ ๋์
Heroku ๋ฐฐํฌ ๋จ๊ณ
1. Procfile ์์ฑ
web: gunicorn web_app:app
2. requirements.txt ์ ๋ฐ์ดํธ
pip freeze > requirements.txt
echo "gunicorn==20.1.0" >> requirements.txt
3. runtime.txt ์์ฑ
python-3.11.0
4. Heroku CLI๋ก ๋ฐฐํฌ
heroku login
heroku create your-app-name
git push heroku main
5. ํ๊ฒฝ๋ณ์ ์ค์
heroku config:set GEMINI_API_KEY=your_api_key_here
์ต์ 2: Google Cloud Run ๋ฐฐํฌ
Gemini API๊ฐ Google ์๋น์ค๋๊น, Cloud Run์ผ๋ก ๋ฐฐํฌํ๋ฉด ํตํฉ์ด ๋ ์์ฐ์ค๋ฌ์! ๐
Cloud Run ๋ฐฐํฌ ๋จ๊ณ
1. Dockerfile ์์ฑ
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 web_app:app
2. .dockerignore ์์ฑ
venv/
__pycache__/
*.pyc
.env
cache/
*.json
3. Google Cloud SDK๋ก ๋ฐฐํฌ
gcloud builds submit --tag gcr.io/PROJECT_ID/youtube-summarizer
gcloud run deploy youtube-summarizer \
--image gcr.io/PROJECT_ID/youtube-summarizer \
--platform managed \
--region asia-northeast3 \
--allow-unauthenticated \
--set-env-vars GEMINI_API_KEY=your_api_key_here
์ฝ๋ ์คํํธ ์ต์ ํ: ์ฒซ ์์ฒญ ์ ์ฝ๊ฐ์ ์ง์ฐ์ด ์์ ์ ์์ง๋ง, ์ต์ ์ธ์คํด์ค๋ฅผ 1๋ก ์ค์ ํ๋ฉด ํด๊ฒฐ๋ผ.
Google ์ํ๊ณ ํตํฉ: Cloud Storage, BigQuery ๋ฑ ๋ค๋ฅธ Google ์๋น์ค์ ์ฐ๋์ด ์ฌ์! ๐
์ต์ 3: AWS Lambda + API Gateway
์๋ฒ๋ฆฌ์ค ์ํคํ ์ฒ๋ฅผ ์ ํธํ๋ค๋ฉด AWS Lambda๋ ์ข์ ์ ํ์ด์ผ!
Lambda ๋ฐฐํฌ ์ ์ฃผ์์ฌํญ:
โ ๏ธ ์คํ ์๊ฐ ์ ํ: Lambda๋ ์ต๋ 15๋ถ๊น์ง๋ง ์คํ๋ผ. ๊ธด ์์ ์ฒ๋ฆฌ ์ ํ์์์ ๊ฐ๋ฅ์ฑ์ด ์์ด.
โ ๏ธ ํจํค์ง ํฌ๊ธฐ: ๋ฐฐํฌ ํจํค์ง๊ฐ 250MB๋ฅผ ๋์ผ๋ฉด ์ ๋ผ. ์์กด์ฑ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ต์ํํด์ผ ํด.
โ
ํด๊ฒฐ์ฑ
: Lambda Layer๋ฅผ ์ฌ์ฉํ๊ฑฐ๋, ๊ธด ์์
์ Step Functions๋ก ๋ถํ ์ฒ๋ฆฌํ๋ฉด ๋ผ!
๐ฐ ๋น์ฉ ์ต์ ํ ์ ๋ต
AI ์๋น์ค๋ฅผ ์ด์ํ๋ค ๋ณด๋ฉด ๋น์ฉ์ด ์๊ฐ๋ณด๋ค ๋น ๋ฅด๊ฒ ๋์ด๋ ์ ์์ด. ๋๋ํ๊ฒ ๋น์ฉ์ ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์! ๐ธ
| ํญ๋ชฉ | ๋ฌด๋ฃ ํฐ์ด | ์ ๋ฃ (Pay-as-you-go) | ์ต์ ํ ํ |
|---|---|---|---|
| Gemini API | ๋ถ๋น 15 ์์ฒญ ์ผ์ผ 1,500 ์์ฒญ |
์
๋ ฅ 1M ํ ํฐ๋น $0.35 ์ถ๋ ฅ 1M ํ ํฐ๋น $1.05 |
์บ์ฑ ํ์ฉ ํ๋กฌํํธ ์ต์ ํ |
| YouTube API | ์ผ์ผ 10,000 ํ ๋น๋ | ์ถ๊ฐ ํ ๋น๋ ๊ตฌ๋งค ๊ฐ๋ฅ | ์๋ง๋ง ์ถ์ถ ์ ๋ถํ์ |
| ์๋ฒ ํธ์คํ | Heroku: 550์๊ฐ/์ Cloud Run: 200๋ง ์์ฒญ/์ |
์ฌ์ฉ๋์ ๋ฐ๋ผ ๋ณ๋ | ์บ์ฑ์ผ๋ก ์์ฒญ ์ ๊ฐ์ |
๐ก ์ค์ ๋น์ฉ ์ ๊ฐ ํ
1. ์ค๋งํธ ์บ์ฑ ์ ๋ต
๊ฐ์ ์์์ ์ฌ๋ฌ ๋ฒ ์์ฝํ์ง ์๋๋ก ์บ์ ๊ธฐ๊ฐ์ ์ ์ ํ ์ค์ ํด. ์ธ๊ธฐ ์์์ 30์ผ, ์ผ๋ฐ ์์์ 7์ผ ์ ๋๊ฐ ์ ๋นํด! ๐
2. ํ๋กฌํํธ ๊ธธ์ด ์ต์ ํ
๋ถํ์ํ๊ฒ ๊ธด ํ๋กฌํํธ๋ ํ ํฐ์ ๋ญ๋นํด. ํต์ฌ๋ง ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ๋, ํ์ง์ ์ ์งํด์ผ ํด. โ๏ธ
3. ๋ฐฐ์น ์ฒ๋ฆฌ ํ์ฉ
์ฌ๋ฌ ์์ฒญ์ ๋ชจ์์ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ฉด ํจ์จ์ ์ด์ผ. ํนํ ๊ฐ์ ์ฑ๋์ ์์๋ค์ ๋ถ์ํ ๋ ์ ์ฉํด! ๐ฆ
4. ์์ฝ ๊ธธ์ด ์ ํ
max_output_tokens๋ฅผ ์ ์ ํ ์ค์ ํด์ ๋ถํ์ํ๊ฒ ๊ธด ์์ฝ์ด ์์ฑ๋์ง ์๋๋ก ํด. 2048 ํ ํฐ์ด๋ฉด ๋๋ถ๋ถ ์ถฉ๋ถํด! ๐
5. ๋ชจ๋ํฐ๋ง ์์คํ
๊ตฌ์ถ
API ์ฌ์ฉ๋์ ์ค์๊ฐ์ผ๋ก ๋ชจ๋ํฐ๋งํด์ ์์์น ๋ชปํ ๋น์ฉ ์ฆ๊ฐ๋ฅผ ๋น ๋ฅด๊ฒ ๊ฐ์งํด์ผ ํด. ๐
import json
from datetime import datetime, timedelta
from pathlib import Path
class UsageMonitor:
def __init__(self, log_file: str = 'usage_log.json'):
self.log_file = Path(log_file)
self.load_logs()
def load_logs(self):
"""๋ก๊ทธ ํ์ผ ๋ก๋"""
if self.log_file.exists():
with open(self.log_file, 'r') as f:
self.logs = json.load(f)
else:
self.logs = []
def log_request(self, video_id: str, tokens_used: int, cost: float):
"""API ์์ฒญ ๋ก๊น
"""
log_entry = {
'timestamp': datetime.now().isoformat(),
'video_id': video_id,
'tokens_used': tokens_used,
'cost': cost
}
self.logs.append(log_entry)
self.save_logs()
def save_logs(self):
"""๋ก๊ทธ ์ ์ฅ"""
with open(self.log_file, 'w') as f:
json.dump(self.logs, f, indent=2)
def get_daily_usage(self, days: int = 7) -> dict:
"""์ผ๋ณ ์ฌ์ฉ๋ ํต๊ณ"""
cutoff_date = datetime.now() - timedelta(days=days)
recent_logs = [
log for log in self.logs
if datetime.fromisoformat(log['timestamp']) > cutoff_date
]
total_tokens = sum(log['tokens_used'] for log in recent_logs)
total_cost = sum(log['cost'] for log in recent_logs)
return {
'period_days': days,
'total_requests': len(recent_logs),
'total_tokens': total_tokens,
'total_cost': total_cost,
'avg_tokens_per_request': total_tokens / len(recent_logs) if recent_logs else 0,
'avg_cost_per_request': total_cost / len(recent_logs) if recent_logs else 0
}
def check_budget_alert(self, daily_budget: float) -> bool:
"""์ผ์ผ ์์ฐ ์ด๊ณผ ์ฒดํฌ"""
today_usage = self.get_daily_usage(days=1)
if today_usage['total_cost'] > daily_budget:
print(f"โ ๏ธ ์์ฐ ์ด๊ณผ ๊ฒฝ๊ณ ! ์ค๋ ์ฌ์ฉ์ก: ${today_usage['total_cost']:.2f}")
return True
return False
๐ ์ค์ ํ์ฉ ์ฌ๋ก
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ง๋ ๋ด์ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ ์ ์๋์ง ๊ตฌ์ฒด์ ์ธ ์ฌ๋ก๋ฅผ ์ดํด๋ณด์! ๐ผ
๐ ์ฌ๋ก 1: ์จ๋ผ์ธ ๊ฐ์ ํ๋ซํผ
์๋๋ฆฌ์ค: ์จ๋ผ์ธ ๊ต์ก ํ๋ซํผ์์ ์๋ฐฑ ๊ฐ์ ๊ฐ์ ์์์ ๊ด๋ฆฌํ๊ณ ์์ด. ํ์๋ค์ด ๊ฐ์ ๋ด์ฉ์ ๋ฏธ๋ฆฌ ํ์
ํ ์ ์๋๋ก ์๋ ์์ฝ ๊ธฐ๋ฅ์ ์ ๊ณตํ๊ณ ์ถ์ด.
๊ตฌํ ๋ฐฉ๋ฒ:
1. ๊ฐ์ ์
๋ก๋ ์ ์๋์ผ๋ก ์์ฝ ์์ฑ
2. 'technical' ์คํ์ผ๋ก ํ์ต ๋ชฉํ์ ํต์ฌ ๊ฐ๋
์ถ์ถ
3. ์ฑํฐ๋ณ๋ก ๋ถํ ์์ฝ ์ ๊ณต
4. ํ์ต ์ง๋์ ๋ฐ๋ผ ๊ด๋ จ ์์ ์ถ์ฒ
๊ธฐ๋ ํจ๊ณผ:
โ
ํ์๋ค์ ๊ฐ์ ์ ํ ์๊ฐ ๋จ์ถ
โ
๋ณต์ต ์ ํต์ฌ ๋ด์ฉ ๋น ๋ฅธ ํ์ธ
โ
๊ฐ์ ํ์ง ๊ด๋ฆฌ ์๋ํ
์ฌ๋ฅ๋ท ํ์ฉ: ์ด๋ฐ ๊ธฐ๋ฅ์ ๊ตฌํํด์ฃผ๋ ์๋น์ค๋ฅผ ์ฌ๋ฅ๋ท์์ ์ ๊ณตํ ์ ์์ด! ๊ต์ก ํ๋ซํผ ์ด์์๋ค์๊ฒ ํฐ ๋์์ด ๋ ๊ฑฐ์ผ. ๐ฏ
๐ฐ ์ฌ๋ก 2: ๋ด์ค ๋ชจ๋ํฐ๋ง ์๋น์ค
์๋๋ฆฌ์ค: ํน์ ์ฃผ์ (์: AI ๊ธฐ์ , ์คํํธ์
ํธ๋ ๋)์ ๊ดํ ์ ํ๋ธ ์์๋ค์ ๋งค์ผ ๋ชจ๋ํฐ๋งํ๊ณ ์์ฝ ๋ฆฌํฌํธ๋ฅผ ์์ฑํ๊ณ ์ถ์ด.
๊ตฌํ ๋ฐฉ๋ฒ:
1. YouTube Data API๋ก ํค์๋ ๊ฒ์
2. ์๋ก์ด ์์ ์๋ ๊ฐ์ง
3. 'brief' ์คํ์ผ๋ก ๋น ๋ฅธ ์์ฝ
4. ์ผ์ผ ๋ค์ด์ ์คํธ ์ด๋ฉ์ผ ๋ฐ์ก
์ฝ๋ ์์:
from googleapiclient.discovery import build
import schedule
import time
class NewsMonitor:
def __init__(self, youtube_api_key, keywords):
self.youtube = build('youtube', 'v3', developerKey=youtube_api_key)
self.keywords = keywords
self.summarizer = YouTubeSummarizerBot()
def search_videos(self, keyword, published_after):
"""ํค์๋๋ก ์ต์ ์์ ๊ฒ์"""
request = self.youtube.search().list(
part='snippet',
q=keyword,
type='video',
publishedAfter=published_after,
maxResults=10,
order='date'
)
response = request.execute()
return response['items']
def generate_daily_report(self):
"""์ผ์ผ ๋ฆฌํฌํธ ์์ฑ"""
from datetime import datetime, timedelta
yesterday = (datetime.now() - timedelta(days=1)).isoformat() + 'Z'
report = []
for keyword in self.keywords:
videos = self.search_videos(keyword, yesterday)
for video in videos:
video_id = video['id']['videoId']
url = f"https://www.youtube.com/watch?v={video_id}"
summary = self.summarizer.process_video(url, style='brief')
if summary['success']:
report.append({
'keyword': keyword,
'title': video['snippet']['title'],
'url': url,
'summary': summary['summary']
})
return report
# ๋งค์ผ ์ค์ 9์์ ์คํ
monitor = NewsMonitor(youtube_api_key='YOUR_KEY', keywords=['AI', 'Machine Learning'])
schedule.every().day.at("09:00").do(monitor.generate_daily_report)
while True:
schedule.run_pending()
time.sleep(60)
๐ฌ ์ฌ๋ก 3: ์ฝํ ์ธ ํฌ๋ฆฌ์์ดํฐ ๋๊ตฌ
์๋๋ฆฌ์ค: ์ ํ๋ฒ๊ฐ ๊ฒฝ์ ์ฑ๋์ ์์๋ค์ ๋ถ์ํด์ ํธ๋ ๋๋ฅผ ํ์
ํ๊ณ ์ถ์ด.
๊ตฌํ ๋ฐฉ๋ฒ:
1. ๊ฒฝ์ ์ฑ๋์ ์ต๊ทผ ์์ 10๊ฐ ์์ง
2. ๊ฐ ์์์ ์ฃผ์ ์ฃผ์ ์ ํค์๋ ์ถ์ถ
3. ํธ๋ ๋ ๋ถ์ ๋ฆฌํฌํธ ์์ฑ
4. ์ฝํ
์ธ ์์ด๋์ด ์ ์
์ถ๊ฐ ๊ธฐ๋ฅ:
- ์์ ๊ธธ์ด๋ณ ์ต์ ํฌ๋งท ๋ถ์
- ์ธ๊ธฐ ์๋ ์ธ๋ค์ผ ์คํ์ผ ํ์
- ์์ฒญ์ ๋ฐ์ ํค์๋ ์ถ์ถ
์ด๋ฐ ๋๊ตฌ๋ฅผ ์ฌ๋ฅ๋ท์์ "์ ํ๋ธ ์ฑ๋ ๋ถ์ ์๋น์ค"๋ก ์ ๊ณตํ๋ฉด ๋ง์ ํฌ๋ฆฌ์์ดํฐ๋ค์ด ๊ด์ฌ ๊ฐ์ง ๊ฑฐ์ผ! ๐
๐ข ์ฌ๋ก 4: ๊ธฐ์ ๊ต์ก ์๋ฃ ๊ด๋ฆฌ
์๋๋ฆฌ์ค: ํ์ฌ์์ ์ง์ ๊ต์ก์ฉ ์์์ด ์๋ฐฑ ๊ฐ์ธ๋ฐ, ๊ฐ ์์์ ๋ด์ฉ์ ๋ฐ์ดํฐ๋ฒ ์ด์คํํ๊ณ ๊ฒ์ ๊ฐ๋ฅํ๊ฒ ๋ง๋ค๊ณ ์ถ์ด.
๊ตฌํ ๋ฐฉ๋ฒ:
1. ๋ชจ๋ ๊ต์ก ์์ ์ผ๊ด ์์ฝ
2. ํค์๋ ์๋ ํ๊น
3. ๋ฒกํฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅ (Pinecone, Weaviate ๋ฑ)
4. ์๋งจํฑ ๊ฒ์ ๊ธฐ๋ฅ ๊ตฌํ
๊ณ ๊ธ ๊ธฐ๋ฅ:
from sentence_transformers import SentenceTransformer
import pinecone
class VideoKnowledgeBase:
def __init__(self):
self.summarizer = YouTubeSummarizerBot()
self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
# Pinecone ์ด๊ธฐํ
pinecone.init(api_key='YOUR_API_KEY', environment='us-west1-gcp')
self.index = pinecone.Index('video-summaries')
def add_video(self, url):
"""์์์ ์ง์ ๋ฒ ์ด์ค์ ์ถ๊ฐ"""
# ์์ฝ ์์ฑ
result = self.summarizer.process_video(url, style='detailed')
if not result['success']:
return False
# ์๋ฒ ๋ฉ ์์ฑ
embedding = self.encoder.encode(result['summary'])
# Pinecone์ ์ ์ฅ
self.index.upsert([(
result['video_id'],
embedding.tolist(),
{
'url': url,
'summary': result['summary'],
'title': result.get('title', '')
}
)])
return True
def search(self, query, top_k=5):
"""์์ฐ์ด ์ฟผ๋ฆฌ๋ก ๊ด๋ จ ์์ ๊ฒ์"""
query_embedding = self.encoder.encode(query)
results = self.index.query(
query_embedding.tolist(),
top_k=top_k,
include_metadata=True
)
return [
{
'video_id': match['id'],
'score': match['score'],
'url': match['metadata']['url'],
'summary': match['metadata']['summary']
}
for match in results['matches']
]
# ์ฌ์ฉ ์์
kb = VideoKnowledgeBase()
# ์์ ์ถ๊ฐ
kb.add_video("https://www.youtube.com/watch?v=VIDEO_ID")
# ๊ฒ์
results = kb.search("๋จธ์ ๋ฌ๋ ๊ธฐ์ด ๊ฐ๋
")
for result in results:
print(f"๊ด๋ จ๋: {result['score']:.2f}")
print(f"URL: {result['url']}")
print(f"์์ฝ: {result['summary'][:200]}...")
print()
๐ ๋ฌธ์ ํด๊ฒฐ ๊ฐ์ด๋
๊ฐ๋ฐํ๋ค ๋ณด๋ฉด ์์์น ๋ชปํ ๋ฌธ์ ๋ค์ด ์๊ธฐ๊ธฐ ๋ง๋ จ์ด์ผ. ์์ฃผ ๋ฐ์ํ๋ ์ด์๋ค๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ดค์ด! ๐ง
โ ๋ฌธ์ 1: "์๋ง์ ์ฐพ์ ์ ์์ต๋๋ค"
์์ธ:
- ์์์ ์๋ง์ด ์์
- ์๋ง์ด ๋นํ์ฑํ๋จ
- ์ง์ํ์ง ์๋ ์ธ์ด
ํด๊ฒฐ ๋ฐฉ๋ฒ:
1. ์๋ ์์ฑ ์๋ง ํ์ฑํ ์ฌ๋ถ ํ์ธ
2. ๋ค๋ฅธ ์ธ์ด ์๋ง ์๋
3. ์์ ์์ ์์๊ฒ ์๋ง ์ถ๊ฐ ์์ฒญ
4. ์์ฑ ์ธ์ API ์ฌ์ฉ (Whisper API ๋ฑ)
# Whisper API๋ฅผ ์ฌ์ฉํ ๋์ฒด ๋ฐฉ๋ฒ
import openai
def transcribe_audio(video_url):
# ์์์์ ์ค๋์ค ์ถ์ถ (youtube-dl ์ฌ์ฉ)
import youtube_dl
ydl_opts = {
'format': 'bestaudio/best',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
}],
'outtmpl': 'temp_audio.%(ext)s',
}
with youtube_dl.YoutubeDL(ydl_opts) as ydl:
ydl.download([video_url])
# Whisper๋ก ์์ฑ ์ธ์
with open('temp_audio.mp3', 'rb') as audio_file:
transcript = openai.Audio.transcribe("whisper-1", audio_file)
return transcript['text']
โ ๋ฌธ์ 2: "API ํ ๋น๋ ์ด๊ณผ"
์์ธ:
- ๋ฌด๋ฃ ํฐ์ด ํ๋ ์ด๊ณผ
- ์งง์ ์๊ฐ์ ๋๋ฌด ๋ง์ ์์ฒญ
ํด๊ฒฐ ๋ฐฉ๋ฒ:
1. ์บ์ฑ ์์คํ
๊ฐํ
2. ์์ฒญ ๊ฐ ๋๋ ์ด ์ถ๊ฐ
3. ์ ๋ฃ ํ๋์ผ๋ก ์
๊ทธ๋ ์ด๋
4. ์ฌ๋ฌ API ํค ๋กํ
์ด์
import time
from collections import deque
class RateLimiter:
def __init__(self, max_requests=15, time_window=60):
"""
๋ ์ดํธ ๋ฆฌ๋ฏธํฐ
max_requests: ์๊ฐ ์๋์ฐ ๋ด ์ต๋ ์์ฒญ ์
time_window: ์๊ฐ ์๋์ฐ (์ด)
"""
self.max_requests = max_requests
self.time_window = time_window
self.requests = deque()
def wait_if_needed(self):
"""ํ์์ ๋๊ธฐ"""
now = time.time()
# ์ค๋๋ ์์ฒญ ๊ธฐ๋ก ์ ๊ฑฐ
while self.requests and now - self.requests[0] > self.time_window:
self.requests.popleft()
# ํ๋ ์ด๊ณผ ์ ๋๊ธฐ
if len(self.requests) >= self.max_requests:
sleep_time = self.time_window - (now - self.requests[0])
if sleep_time > 0:
print(f"โณ ๋ ์ดํธ ๋ฆฌ๋ฐ: {sleep_time:.1f}์ด ๋๊ธฐ ์ค...")
time.sleep(sleep_time)
self.requests.popleft()
self.requests.append(now)
# ์ฌ์ฉ ์์
limiter = RateLimiter(max_requests=15, time_window=60)
for url in video_urls:
limiter.wait_if_needed()
result = summarizer.process_video(url)
โ ๋ฌธ์ 3: "์์ฝ ํ์ง์ด ๋ฎ์"
์์ธ:
- ํ๋กฌํํธ๊ฐ ๋ถ๋ช
ํํจ
- ์๋ง ํ์ง์ด ๋ฎ์ (์๋ ์์ฑ)
- ์์ ๋ด์ฉ์ด ์ฐ๋งํจ
ํด๊ฒฐ ๋ฐฉ๋ฒ:
1. ํ๋กฌํํธ ๊ฐ์ ๋ฐ ๊ตฌ์ฒดํ
2. Few-shot ์์ ์ถ๊ฐ
3. ํ์ฒ๋ฆฌ ๋จ๊ณ ์ถ๊ฐ
4. ๋ ๊ฐ๋ ฅํ ๋ชจ๋ธ ์ฌ์ฉ (Gemini 1.5 Pro)
def create_enhanced_prompt(transcript):
"""๊ฐ์ ๋ ํ๋กฌํํธ ์์ฑ"""
return f"""
๋ค์์ ์ ํ๋ธ ์์์ ์๋ง์
๋๋ค. ๊ณ ํ์ง ์์ฝ์ ์์ฑํด์ฃผ์ธ์.
์๋ง:
{transcript}
์์ฝ ์์ฑ ๊ฐ์ด๋๋ผ์ธ:
1. ํต์ฌ ๋ฉ์์ง๋ฅผ ๋ช
ํํ ํ์
2. ์ค์๋ ์์ผ๋ก ๋ด์ฉ ์ ๋ฆฌ
3. ๊ตฌ์ฒด์ ์ธ ์์๋ ์์น ํฌํจ
4. ๋
ผ๋ฆฌ์ ํ๋ฆ ์ ์ง
5. ์ ๋ฌธ ์ฉ์ด๋ ์ฝ๊ฒ ํ์ด์ ์ค๋ช
์ข์ ์์ฝ ์์:
"์ด ์์์ ๋จธ์ ๋ฌ๋์ ๊ธฐ์ด ๊ฐ๋
์ ๋ค๋ฃน๋๋ค. ์ฃผ์ ๋ด์ฉ์:
1. ์ง๋ํ์ต๊ณผ ๋น์ง๋ํ์ต์ ์ฐจ์ด (์ ํ๋ 85% vs 70%)
2. ์ค์ ํ๋ก์ ํธ 3๊ฐ์ง ์์
3. ์ด๋ณด์๊ฐ ํผํด์ผ ํ 5๊ฐ์ง ์ค์
๊ฒฐ๋ก ์ ์ผ๋ก, ์ฒด๊ณ์ ์ธ ํ์ต ๋ก๋๋งต์ด ์ค์ํฉ๋๋ค."
์ ๊ฐ์ด๋๋ผ์ธ์ ๋ฐ๋ผ ์์ฝ์ ์์ฑํด์ฃผ์ธ์:
"""
โ ๋ฌธ์ 4: "๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ์ค๋ฅ"
์์ธ:
- ๋งค์ฐ ๊ธด ์์ (2์๊ฐ ์ด์)
- ์ฌ๋ฌ ์์ ๋์ ์ฒ๋ฆฌ
- ๋ฉ๋ชจ๋ฆฌ ๋์
ํด๊ฒฐ ๋ฐฉ๋ฒ:
1. ์๋ง์ ์ฒญํฌ๋ก ๋ถํ ์ฒ๋ฆฌ
2. ์คํธ๋ฆฌ๋ฐ ๋ฐฉ์ ๊ตฌํ
3. ๊ฐ๋น์ง ์ปฌ๋ ์
๋ช
์์ ํธ์ถ
4. ์๋ฒ ๋ฉ๋ชจ๋ฆฌ ์ฆ์ค
def chunk_transcript(transcript, chunk_size=5000):
"""์๋ง์ ์ฒญํฌ๋ก ๋ถํ """
words = transcript.split()
chunks = []
for i in range(0, len(words), chunk_size):
chunk = ' '.join(words[i:i + chunk_size])
chunks.append(chunk)
return chunks
def summarize_long_video(transcript):
"""๊ธด ์์ ์์ฝ (์ฒญํฌ ๋ฐฉ์)"""
chunks = chunk_transcript(transcript)
chunk_summaries = []
for i, chunk in enumerate(chunks):
print(f"์ฒญํฌ {i+1}/{len(chunks)} ์ฒ๋ฆฌ ์ค...")
summary = summarizer.summarize(chunk, style='brief')
if summary['success']:
chunk_summaries.append(summary['summary'])
# ๋ฉ๋ชจ๋ฆฌ ์ ๋ฆฌ
import gc
gc.collect()
# ์ต์ข
ํตํฉ ์์ฝ
combined = '\n\n'.join(chunk_summaries)
final_summary = summarizer.summarize(
f"๋ค์์ ์์์ ๋ถ๋ถ ์์ฝ๋ค์
๋๋ค. ์ด๋ฅผ ํตํฉํด์ ์ ์ฒด ์์ฝ์ ์์ฑํด์ฃผ์ธ์:\n\n{combined}",
style='detailed'
)
return final_summary
๐ ํ์ฅ ์์ด๋์ด
๊ธฐ๋ณธ ๊ธฐ๋ฅ์ ๋์ด์ ๋ ๋ฐ์ ์ํฌ ์ ์๋ ์์ด๋์ด๋ค์ ์๊ฐํ ๊ฒ! ์ด ์ค ํ๋๋ผ๋ ๊ตฌํํ๋ฉด ์ ๋ง ๋ฉ์ง ์๋น์ค๊ฐ ๋ ๊ฑฐ์ผ. ๐ก
1. ๐๏ธ ํ์บ์คํธ ์๋ ์์ฑ
์์ฝ๋ ๋ด์ฉ์ TTS(Text-to-Speech)๋ก ๋ณํํด์ ์ค๋์ค ํ์บ์คํธ๋ฅผ ๋ง๋ค์ด์ค. ์ถํด๊ทผ๊ธธ์ ๋ฃ๊ธฐ ์ข๊ฒ ์ง?
๊ตฌํ ๋ฐฉ๋ฒ:
- Google Cloud Text-to-Speech API ์ฌ์ฉ
- ์์ฐ์ค๋ฌ์ด ์์ฑ ํฉ์ฑ
- ๋ฐฐ๊ฒฝ ์์
์ถ๊ฐ
- RSS ํผ๋ ์์ฑ
2. ๐ ์๊ฐํ ๋์๋ณด๋
์ฑ๋๋ณ, ์ฃผ์ ๋ณ ํธ๋ ๋๋ฅผ ์๊ฐํํ๋ ๋์๋ณด๋๋ฅผ ๋ง๋ค์ด๋ด. ๋ฐ์ดํฐ ๋ถ์๊ฐ๋ค์ด ์ข์ํ ๊ฑฐ์ผ!
๊ธฐ๋ฅ:
- ์ธ๊ธฐ ํค์๋ ์๋ํด๋ผ์ฐ๋
- ์๊ฐ๋๋ณ ์กฐํ์ ์ถ์ด
- ์ฃผ์ ๋ณ ์์ ๋ถํฌ
- ๊ฒฝ์ ์ฑ๋ ๋น๊ต ๋ถ์
3. ๐ค ํ์ ๊ธฐ๋ฅ
ํ์๋ค๊ณผ ํจ๊ป ์์์ ๋ถ์ํ๊ณ ๋ฉ๋ชจ๋ฅผ ๊ณต์ ํ ์ ์๋ ๊ธฐ๋ฅ!
๊ธฐ๋ฅ:
- ์์ฝ์ ๋๊ธ ๋ฌ๊ธฐ
- ์ค์ ๋ถ๋ถ ํ์ด๋ผ์ดํธ
- ํ ์ํฌ์คํ์ด์ค
- ๊ถํ ๊ด๋ฆฌ
4. ๐ฑ ๋ชจ๋ฐ์ผ ์ฑ
React Native๋ Flutter๋ก ๋ชจ๋ฐ์ผ ์ฑ์ ๋ง๋ค๋ฉด ๋ ๋ง์ ์ฌ์ฉ์์๊ฒ ๋ค๊ฐ๊ฐ ์ ์์ด!
ํน์ง:
- ์คํ๋ผ์ธ ๋ชจ๋ (์บ์๋ ์์ฝ)
- ํธ์ ์๋ฆผ (์ ์์ ์๋ฆผ)
- ์์ฑ ๋ช
๋ น ์ง์
- ๋คํฌ ๋ชจ๋
5. ๐ ํ์ต ๋์ฐ๋ฏธ
์์ฝ๊ณผ ํจ๊ป ํด์ฆ๋ฅผ ์๋ ์์ฑํด์ ํ์ต ํจ๊ณผ๋ฅผ ๋์ฌ์ค!
๊ธฐ๋ฅ:
- ์ดํด๋ ์ฒดํฌ ํด์ฆ
- ํ๋์์นด๋ ์์ฑ
- ํ์ต ์ง๋ ์ถ์
- ๋ณต์ต ์๋ฆผ
def generate_quiz(summary):
"""์์ฝ์์ ํด์ฆ ์์ฑ"""
prompt = f"""
๋ค์ ์์ฝ ๋ด์ฉ์ ๋ฐํ์ผ๋ก ํ์ต ํด์ฆ๋ฅผ 5๊ฐ ๋ง๋ค์ด์ฃผ์ธ์:
{summary}
๊ฐ ํด์ฆ๋ ๋ค์ ํ์์ผ๋ก:
1. ์ง๋ฌธ
2. 4๊ฐ์ ์ ํ์ง (์ ๋ต 1๊ฐ)
3. ์ ๋ต ๋ฒํธ
4. ํด์ค
JSON ํ์์ผ๋ก ๋ฐํํด์ฃผ์ธ์.
"""
response = summarizer.model.generate_content(prompt)
quiz_data = json.loads(response.text)
return quiz_data
๐ฏ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์! ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด. ์ฐ๋ฆฌ๋ Gemini API๋ฅผ ํ์ฉํด์ ์ ํ๋ธ ์์ ์๋์์ฝ ๋ด์ ์ฒ์๋ถํฐ ๋๊น์ง ๋ง๋ค์ด๋ดค์ด. ๐
์ด ํ๋ก์ ํธ๋ฅผ ํตํด ๋ฐฐ์ด ๊ฒ๋ค์ ์ ๋ฆฌํด๋ณด๋ฉด:
โจ ํต์ฌ ์์ฝ
1. AI API ํ์ฉ
Gemini API์ ๊ฐ๋ ฅํ ๋ฉํฐ๋ชจ๋ฌ ๊ธฐ๋ฅ๊ณผ ๊ธด ์ปจํ
์คํธ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ์ค์ ์์ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ์ด. ๋จ์ํ API๋ฅผ ํธ์ถํ๋ ๊ฒ์ ๋์ด์, ํ๋กฌํํธ ์์ง๋์ด๋ง๊ณผ ์๋ฌ ํธ๋ค๋ง๊น์ง ๋ง์คํฐํ์ง! ๐ค
2. ์๋ํ ์์คํ
๊ตฌ์ถ
์ ํ๋ธ ์๋ง ์ถ์ถ๋ถํฐ AI ์์ฝ, ๊ฒฐ๊ณผ ์ ์ฅ๊น์ง ์ ์ฒด ํ์ดํ๋ผ์ธ์ ์๋ํํ์ด. ์ด๋ฐ ๊ฒฝํ์ ๋ค๋ฅธ AI ํ๋ก์ ํธ์๋ ๊ทธ๋๋ก ์ ์ฉํ ์ ์์ด! โ๏ธ
3. ์ฑ๋ฅ ์ต์ ํ
์บ์ฑ, ๋น๋๊ธฐ ์ฒ๋ฆฌ, ๋ ์ดํธ ๋ฆฌ๋ฏธํ
๋ฑ ์ค์ ์๋น์ค ์ด์์ ํ์ํ ์ต์ ํ ๊ธฐ๋ฒ๋ค์ ๋ฐฐ์ ์ด. ์ด์ ํ์ฅ ๊ฐ๋ฅํ ์์คํ
์ ์ค๊ณํ ์ ์๊ฒ ๋์ง! ๐
4. ์ค์ ๋ฐฐํฌ
๋ก์ปฌ ๊ฐ๋ฐ ํ๊ฒฝ์์ ํด๋ผ์ฐ๋ ๋ฐฐํฌ๊น์ง, ์ ์ฒด ๊ฐ๋ฐ ์ฌ์ดํด์ ๊ฒฝํํ์ด. Heroku, Cloud Run, AWS Lambda ๋ฑ ๋ค์ํ ๋ฐฐํฌ ์ต์
๋ ์์๋ดค๊ณ ! โ๏ธ
5. ๋น์ฆ๋์ค ํ์ฉ
๋จ์ํ ํ ์ด ํ๋ก์ ํธ๊ฐ ์๋๋ผ, ์ค์ ๋ก ์์ต์ ์ฐฝ์ถํ ์ ์๋ ์๋น์ค๋ก ๋ฐ์ ์ํค๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ์ด. ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์๋น์ค๋ฅผ ์ ๊ณตํ ์๋ ์๊ณ ! ๐ผ
2. ์ปค๋ฎค๋ํฐ ์ฐธ์ฌ: ๋ง๋ ๋ด์ ์คํ์์ค๋ก ๊ณต๊ฐํ๊ณ , ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค๊ณผ ์์ด๋์ด๋ฅผ ๊ณต์ ํด๋ด. ํผ๋๋ฐฑ์ ๋ฐ์ผ๋ฉด์ ๋ ๋ฐ์ ํ ์ ์์ด!
3. ์์ตํ ์๋: ์ฌ๋ฅ๋ท์ด๋ ๋ค๋ฅธ ํ๋ซํผ์์ ์๋น์ค๋ฅผ ์ ๊ณตํด๋ด. ์๊ฒ ์์ํด์ ์ ์ ํค์๋๊ฐ๋ ๊ฑฐ์ง!
4. ๊ธฐ์ ํ์ฅ: ์ด๋ฏธ์ง ๋ถ์, ์์ฑ ์ธ์ ๋ฑ ๋ค๋ฅธ AI ๊ธฐ๋ฅ๋ ์ถ๊ฐํด๋ด. ๋ฉํฐ๋ชจ๋ฌ AI์ ๊ฐ๋ฅ์ฑ์ ๋ฌด๊ถ๋ฌด์งํด!
5. ๋คํธ์ํน: AI ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์ ์ฐธ์ฌํ๊ณ , ํด์ปคํค์ด๋ ์ปจํผ๋ฐ์ค์๋ ๋๊ฐ๋ด. ์ข์ ๊ธฐํ๋ค์ด ๋ง์ด ์์ด! ๐
๐ ๋น์ ์ AI ์ฌ์ ์ ์ด์ ์์์ด์ผ!
์ด ๊ฐ์ด๋๊ฐ ๋์์ด ๋๋ค๋ฉด, ์ง์ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์คํํด๋ณด๋ ๊ฒ ๊ฐ์ฅ ์ค์ํด. ์๋ฌ๊ฐ ๋๋ ๊ด์ฐฎ์! ๊ทธ๊ฒ ๋ฐ๋ก ๋ฐฐ์ฐ๋ ๊ณผ์ ์ด๋๊น. ๐ช
ํน์ ๋งํ๋ ๋ถ๋ถ์ด ์๊ฑฐ๋ ๋ ๊ถ๊ธํ ๊ฒ ์๋ค๋ฉด, ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์ ์ง๋ฌธ์ ์ฌ๋ ค๋ด. ๋ง์ ์ฌ๋๋ค์ด ๊ธฐ๊บผ์ด ๋์์ค ๊ฑฐ์ผ. ๊ทธ๋ฆฌ๊ณ ์ฌ๋ฅ๋ท์์ AI ์๋ํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ฐพ์๋ณด๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ. ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ์ผ๋ฉด ํจ์ฌ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ ์ ์๊ฑฐ๋ ! ๐ฏ
์, ์ด์ ๋น์ ์ฐจ๋ก์ผ! ํค๋ณด๋๋ฅผ ๋๋๋ฆฌ๊ณ , ์ฝ๋๋ฅผ ์์ฑํ๊ณ , ๋ฉ์ง AI ๋ด์ ๋ง๋ค์ด๋ด. ์ธ์์ ๋น์ ์ ์ฐฝ์์ ์ธ ์์ด๋์ด๋ฅผ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ด! ๐
๐ก ๋ง์ง๋ง ํ๋ง๋
"AI๋ ๋ ์ด์ ๋จผ ๋ฏธ๋์ ๊ธฐ์ ์ด ์๋์ผ.
์ง๊ธ ๋น์ฅ ์์ํ ์ ์๊ณ , ๋๊ตฌ๋ ํ์ฉํ ์ ์์ด.
์ค์ํ ๊ฑด ์ฒซ ๊ฑธ์์ ๋ด๋๋ ์ฉ๊ธฐ์ผ.
๋น์ ์ AI ํ๋ก์ ํธ๊ฐ ์ธ์์ ์กฐ๊ธ ๋ ํธ๋ฆฌํ๊ฒ ๋ง๋ค๊ธฐ๋ฅผ ๋ฐ๋ผ! ๐โจ"
๐ ์ถ๊ฐ ํ์ต ๋ฆฌ์์ค
๊ณต์ ๋ฌธ์:
โข Gemini API ๋ฌธ์: https://ai.google.dev/docs
โข YouTube Data API: https://developers.google.com/youtube/v3
โข Python youtube-transcript-api: https://github.com/jdepoix/youtube-transcript-api
์ปค๋ฎค๋ํฐ:
โข Reddit r/MachineLearning
โข Stack Overflow AI ํ๊ทธ
โข Discord AI ๊ฐ๋ฐ์ ์๋ฒ
์ถ์ฒ ๊ฐ์:
โข Google Cloud Skills Boost
โข Coursera AI ๊ณผ์
โข YouTube AI ํํ ๋ฆฌ์ผ ์ฑ๋๋ค
์ฌ๋ฅ๋ท ํ์ฉ:
AI ์๋ํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ ๊ณตํ๊ฑฐ๋, ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ์ ์ ์์ด. ํ๋ก์ ํธ๋ฅผ ๋ ๋น ๋ฅด๊ฒ ์์ฑํ๊ณ ์ถ๋ค๋ฉด ์ฌ๋ฅ๋ท์ ํ์ฉํด๋ณด๋ ๊ฒ๋ ์ข์ ์ ํ์ด์ผ! ๐ผ
๐ ์ถํํด! ์ด์ ๋น์ ๋ AI ์๋ํ ์ ๋ฌธ๊ฐ์ผ! ๐
์ด ์ง์์ ๋ฐํ์ผ๋ก ๋ ๋ฉ์ง ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ด!
ํ์ด์ ๋น์ด! ๐โจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.