npub1al…ajqfd

📦 IndieBiz OS 도구 패키지
이름: Youtube
설명: 에이전트가 YouTube 동영상을 다루는 능력을 제공합니다. 음악 다운로드, 정보 조회, 자막 추출, AI 요약 등을 할 수 있습니다. | 제공 도구: get_youtube_info, get_youtube_transcript, list_available_transcripts, summarize_youtube, download_youtube_music
버전: 1.0.0
설치 방법:
===PACKAGE_START===
id: youtube
name: YouTube Tools
description: YouTube 영상 정보 조회, 자막 추출, 다운로드 도구
===FILE:tool.json===
{
"id": "youtube",
"name": "YouTube Tools",
"description": "YouTube 영상 정보 조회, 자막 추출, 다운로드 도구",
"version": "1.1.0",
"tools": [
{
"name": "get_youtube_info",
"description": "YouTube 영상의 메타데이터를 조회합니다.\n\n## 반환 정보\n- 제목, 채널명, 업로드 날짜\n- 조회수, 좋아요 수, 댓글 수\n- 영상 길이, 설명\n- 썸네일 URL\n\n## 사용 시점\n- 영상 기본 정보 확인\n- 다운로드/자막 추출 전 영상 확인\n- 영상 분석을 위한 메타데이터 수집\n\n## 주의사항\n- 비공개/삭제된 영상은 조회 불가\n- 영상 내용 자체는 포함되지 않음 → get_youtube_transcript 사용",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL (전체 URL 또는 youtu.be 단축 URL)"
}
},
"required": ["url"]
}
},
{
"name": "get_youtube_transcript",
"description": "YouTube 영상의 자막을 텍스트로 추출합니다.\n\n## 사용 시점\n- 영상 내용을 텍스트로 확인\n- 영상 요약/분석을 위한 원본 텍스트 필요\n- 특정 내용 검색 (영상 내 키워드 찾기)\n\n## 사용법\n- url: YouTube URL\n- languages: 선호 언어 순서 (예: ['ko', 'en'])\n- include_timestamps: 타임스탬프 포함 여부\n- max_length: 최대 문자 수 제한\n\n## 주의사항\n- 자막이 없는 영상은 추출 불가 → list_available_transcripts로 먼저 확인\n- 자동 생성 자막은 정확도가 낮을 수 있음\n- 긴 영상은 max_length로 제한 권장 (토큰 절약)\n\n## 다른 도구와의 관계\n- 자막 언어 확인: list_available_transcripts 먼저 사용\n- AI 요약 필요: summarize_youtube 사용",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 언어 순서 (예: ['ko', 'en'])"
},
"include_timestamps": {
"type": "boolean",
"description": "[MM:SS] 타임스탬프 포함 (기본 false)"
},
"merge_segments": {
"type": "boolean",
"description": "60초 단위 병합 (기본 false)"
},
"max_length": {
"type": "integer",
"description": "최대 문자 수 (생략시 제한 없음)"
}
},
"required": ["url"]
}
},
{
"name": "list_available_transcripts",
"description": "YouTube 영상에서 사용 가능한 자막 언어 목록을 조회합니다.\n\n## 사용 시점\n- get_youtube_transcript 호출 전 언어 확인\n- 자막 지원 여부 확인\n- 수동/자동 생성 자막 구분\n\n## 반환 정보\n- 사용 가능한 언어 코드 목록\n- 수동 작성 vs 자동 생성 구분\n- 번역 가능 언어",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
}
},
"required": ["url"]
}
},
{
"name": "summarize_youtube",
"description": "YouTube 영상을 AI로 요약하고 HTML 파일로 저장합니다.\n\n## 처리 과정\n1. 자막 자동 추출\n2. AI 요약 생성\n3. HTML 파일로 저장\n\n## 사용 시점\n- 긴 영상의 핵심 내용 파악\n- 영상 내용 문서화\n- 여러 영상 비교 분석\n\n## 주의사항\n- 자막이 있는 영상만 가능\n- 처리 시간이 길 수 있음 (영상 길이에 따라)\n- summary_length로 요약 길이 조절 가능",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
},
"summary_length": {
"type": "integer",
"description": "요약 길이 (기본 3000자)"
},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 자막 언어"
}
},
"required": ["url"]
}
},
{
"name": "download_youtube_music",
"description": "YouTube 영상에서 오디오를 MP3로 다운로드합니다.\n\n## 사용 시점\n- 음악/팟캐스트 오프라인 저장\n- 오디오만 필요한 경우\n\n## 주의사항\n- 저작권이 있는 콘텐츠는 개인 용도로만 사용\n- 긴 영상은 다운로드 시간이 오래 걸림\n- 기본 저장 위치: 바탕화면/output.mp3",
"input_schema": {
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "YouTube URL"
},
"output_path": {
"type": "string",
"description": "저장 경로 (기본: 바탕화면/output.mp3)"
}
},
"required": ["url"]
}
}
]
}
===FILE:handler.py===
import os
import json
import importlib.util
from pathlib import Path
# 같은 디렉토리의 모듈을 동적으로 로드
current_dir = Path(__file__).parent
def load_tool_youtube():
module_path = current_dir / "tool_youtube.py"
spec = importlib.util.spec_from_file_location("tool_youtube", module_path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, "data")
SETTINGS_PATH = os.path.join(BASE_DIR, "tool_settings.json")
def execute(tool_name: str, arguments: dict, project_path: str = None):
tool_youtube = load_tool_youtube()
if tool_name == 'download_youtube_music':
return tool_youtube.download_youtube_music(url=arguments['url'], filename=arguments.get('output_path', 'output.mp3'))
elif tool_name == 'get_youtube_info':
return tool_youtube.get_youtube_info(url=arguments['url'])
elif tool_name == 'get_youtube_transcript':
# language를 languages 리스트로 변환
lang = arguments.get('language') or arguments.get('languages')
if isinstance(lang, str):
languages = [lang]
elif isinstance(lang, list):
languages = lang
else:
languages = ['ko', 'en']
return tool_youtube.get_youtube_transcript(url=arguments['url'], languages=languages)
elif tool_name == 'list_available_transcripts':
return tool_youtube.list_available_transcripts(url=arguments['url'])
elif tool_name == 'summarize_youtube':
# summary_length와 languages 파라미터 전달
summary_length = arguments.get('summary_length', 3000)
lang = arguments.get('language') or arguments.get('languages')
if isinstance(lang, str):
languages = [lang]
elif isinstance(lang, list):
languages = lang
else:
languages = None # 자동 선택
return tool_youtube.summarize_youtube(
url=arguments['url'],
summary_length=summary_length,
languages=languages
)
else:
raise ValueError(f'Unknown tool: {tool_name}')
===FILE:tool_utils.py===
"""
IndieBiz 도구 공통 유틸리티
==========================
여러 도구에서 공용으로 사용하는 함수들
"""
import os
# 공통 출력 경로
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUTS_DIR = os.path.join(BASE_DIR, "outputs")
def markdown_to_html(markdown_text: str, title: str, date_str: str,
doc_type: str = "default") -> str:
"""
Markdown을 HTML로 변환
Args:
markdown_text: 변환할 마크다운 텍스트
title: 문서 제목
date_str: 날짜 문자열
doc_type: 문서 타입 ("newspaper", "magazine", "report", "default")
Returns:
HTML 문자열
"""
import markdown
# Markdown → HTML 변환
html_body = markdown.markdown(
markdown_text,
extensions=['extra', 'nl2br', 'sane_lists', 'toc']
)
# 문서 타입별 설정
type_config = {
"newspaper": {
"class": "newspaper",
"subtitle": f"{date_str} | IndieBiz AI 신문 시스템"
},
"magazine": {
"class": "magazine",
"subtitle": f"{date_str} | IndieBiz Magazine"
},
"report": {
"class": "report",
"subtitle": f"{date_str} | IndieBiz 블로그 인사이트"
},
"default": {
"class": "document",
"subtitle": date_str
}
}
config = type_config.get(doc_type, type_config["default"])
# 공통 스타일
style = """
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: 'Malgun Gothic', 'Apple SD Gothic Neo', sans-serif;
line-height: 1.8;
background-color: #f5f5f5;
color: #1a1a1a;
}
.newspaper, .magazine, .report, .document {
max-width: 1200px;
margin: 20px auto;
background: white;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}
/* 헤더 */
.header {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 40px;
text-align: center;
}
h1 {
font-size: 42px;
font-weight: bold;
margin-bottom: 10px;
}
.subtitle {
font-size: 14px;
opacity: 0.9;
}
/* 본문 */
.content {
padding: 40px;
}
/* 목차 */
.toc {
background: #f9f9f9;
border-left: 4px solid #667eea;
padding: 20px 30px;
margin-bottom: 40px;
}
.toc h2 {
font-size: 18px;
margin-bottom: 15px;
color: #667eea;
border: none;
}
.toc ul {
list-style: none;
}
.toc li {
margin-bottom: 8px;
padding-left: 20px;
position: relative;
}
.toc li::before {
content: '▸';
position: absolute;
left: 0;
color: #667eea;
}
.toc a {
color: #333;
text-decoration: none;
transition: color 0.3s;
}
.toc a:hover {
color: #667eea;
}
/* 섹션 */
h2 {
font-size: 28px;
color: #667eea;
border-bottom: 2px solid #667eea;
padding-bottom: 10px;
margin: 40px 0 20px 0;
}
/* 기사/항목 */
h3 {
font-size: 20px;
color: #333;
margin: 25px 0 10px 0;
line-height: 1.4;
}
p {
margin-bottom: 15px;
line-height: 1.8;
color: #444;
}
strong {
color: #667eea;
}
/* 링크 */
a {
color: #667eea;
text-decoration: none;
border-bottom: 1px solid transparent;
transition: all 0.3s;
}
a:hover {
border-bottom-color: #667eea;
}
/* 버튼형 링크 */
p a {
display: inline-block;
padding: 8px 16px;
background: #f0f0f0;
border-radius: 4px;
border: none;
font-weight: 500;
}
p a:hover {
background: #667eea;
color: white;
}
/* 구분선 */
hr {
border: none;
height: 1px;
background: #e0e0e0;
margin: 30px 0;
}
/* 푸터 */
.footer {
background: #f9f9f9;
border-top: 2px solid #e0e0e0;
padding: 30px 40px;
margin-top: 40px;
}
.footer h2 {
font-size: 18px;
border: none;
margin: 0 0 15px 0;
color: #667eea;
}
.footer ul {
list-style: none;
color: #666;
font-size: 14px;
}
.footer li {
padding: 5px 0;
padding-left: 20px;
position: relative;
}
.footer li::before {
content: '•';
position: absolute;
left: 0;
color: #667eea;
}
/* 반응형 */
@media (max-width: 768px) {
.newspaper, .magazine, .report, .document {
margin: 10px;
}
.header, .content, .footer {
padding: 20px;
}
h1 {
font-size: 28px;
}
h2 {
font-size: 22px;
}
h3 {
font-size: 18px;
}
}
</style>
"""
# 최종 HTML
html = f"""<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{title} - {date_str}</title>
{style}
</head>
<body>
<div class="{config['class']}">
<div class="header">
<h1>{title}</h1>
<div class="subtitle">{config['subtitle']}</div>
</div>
<div class="content">
{html_body}
</div>
</div>
</body>
</html>"""
return html
def save_as_html(content: str, title: str, date_str: str,
filename_prefix: str, doc_type: str = "default") -> dict:
"""
마크다운 콘텐츠를 HTML로 변환하여 저장
Args:
content: 마크다운 콘텐츠
title: 문서 제목
date_str: 날짜 문자열 (예: "2024년 12월 26일")
filename_prefix: 파일명 접두사 (예: "신문", "잡지")
doc_type: 문서 타입
Returns:
{'success': True, 'filepath': '...', 'filename': '...'}
"""
from datetime import datetime
os.makedirs(OUTPUTS_DIR, exist_ok=True)
# 파일명용 날짜
date_filename = datetime.now().strftime("%Y%m%d")
# HTML 변환
html_content = markdown_to_html(content, title, date_str, doc_type)
# 파일 저장
filename = f"{filename_prefix}_{date_filename}.html"
filepath = os.path.join(OUTPUTS_DIR, filename)
with open(filepath, 'w', encoding='utf-8') as f:
f.write(html_content)
return {
'success': True,
'filepath': filepath,
'filename': filename
}
===FILE:tool_youtube.py===
"""
YouTube 다운로드 도구
- 음악 다운로드 (MP3)
- 동영상 정보 조회
- 자막/트랜스크립트 가져오기
- 동영상 요약 (AI 사용)
"""
import os
import shutil
import re
import json
from datetime import datetime
from typing import Optional, List, Dict, Any
# AI 설정 경로
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, "data")
# 시스템 AI 설정 경로 (indiebizOS/data/system_ai_config.json)
INDIEBIZ_DATA_DIR = os.path.abspath(os.path.join(BASE_DIR, "..", "..", "..", ".."))
SYSTEM_AI_CONFIG_PATH = os.path.join(INDIEBIZ_DATA_DIR, "system_ai_config.json")
OUTPUTS_DIR = os.path.join(INDIEBIZ_DATA_DIR, "outputs")
def markdown_to_html(content: str, title: str, date_str: str, doc_type: str = "report") -> str:
"""마크다운을 HTML로 변환 (간단 버전)"""
try:
import markdown
html_body = markdown.markdown(content, extensions=['tables', 'fenced_code'])
except ImportError:
html_body = f"<pre>{content}</pre>"
return f"""<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{title}</title>
<style>
body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; line-height: 1.6; }}
h1, h2, h3 {{ color: #333; }}
a {{ color: #0066cc; }}
pre {{ background: #f5f5f5; padding: 10px; overflow-x: auto; }}
code {{ background: #f0f0f0; padding: 2px 5px; border-radius: 3px; }}
</style>
</head>
<body>
<h1>{title}</h1>
<p><em>{date_str}</em></p>
<hr>
{html_body}
</body>
</html>"""
def download_youtube_music(url: str, filename: str = "output.mp3") -> dict:
"""YouTube에서 음악을 MP3로 다운로드"""
try:
import yt_dlp
except ImportError:
return {
'success': False,
'message': 'yt_dlp 패키지가 설치되지 않았습니다. pip install yt-dlp 실행 필요'
}
try:
# 동적으로 Desktop 경로 설정 (크로스 플랫폼 지원)
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
if not os.path.isabs(filename):
filename = os.path.join(desktop_path, filename)
if not filename.endswith('.mp3'):
filename += '.mp3'
# FFmpeg 경로 찾기 (크로스 플랫폼)
ffmpeg_path = shutil.which("ffmpeg")
if not ffmpeg_path:
# 일반적인 설치 경로들 확인
common_paths = [
"/opt/homebrew/bin/ffmpeg", # macOS (Apple Silicon)
"/usr/local/bin/ffmpeg", # macOS (Intel) / Linux
"/usr/bin/ffmpeg", # Linux
]
for path in common_paths:
if os.path.isfile(path):
ffmpeg_path = path
break
if not ffmpeg_path or not os.path.isfile(ffmpeg_path):
return {
'success': False,
'message': 'FFmpeg를 찾을 수 없습니다. FFmpeg를 설치해주세요. (brew install ffmpeg)'
}
print(f"[YouTube] 다운로드 시작: {url}")
print(f"[YouTube] 저장 위치: {filename}")
# 진행 상황 표시
def progress_hook(d):
if d['status'] == 'downloading':
print(f"[YouTube] 다운로드 중... {d.get('_percent_str', '?')}%")
elif d['status'] == 'finished':
print(f"[YouTube] 다운로드 완료, MP3 변환 중...")
ydl_opts = {
'format': 'bestaudio/best',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '320',
}],
'outtmpl': filename.rsplit('.mp3', 1)[0],
'ffmpeg_location': ffmpeg_path,
'quiet': False, # 진행 상황 표시
'no_warnings': False,
'noprogress': False,
'progress_hooks': [progress_hook],
'noplaylist': True, # 플레이리스트 무시, 단일 비디오만 다운로드
'extract_flat': False,
}
with yt_dlp.YoutubeDL(ydl_opts) as ydl:
print(f"[YouTube] 비디오 정보 가져오는 중...")
info = ydl.extract_info(url, download=False)
title = info.get('title', 'Unknown')
duration = info.get('duration', 0)
print(f"[YouTube] 제목: {title}")
print(f"[YouTube] 길이: {duration}초")
print(f"[YouTube] 다운로드 시작...")
ydl.download([url])
print(f"[YouTube] 완료! 파일: {filename}")
return {
'success': True,
'file_path': filename,
'title': title,
'duration': duration,
'message': f'다운로드 완료: {title} ({duration}초)'
}
except Exception as e:
print(f"[YouTube] 오류: {str(e)}")
return {
'success': False,
'message': f'다운로드 실패: {str(e)}'
}
def format_timestamp(seconds: float) -> str:
"""초를 HH:MM:SS 또는 MM:SS 형식으로 변환합니다."""
hours = int(seconds // 3600)
minutes = int((seconds % 3600) // 60)
secs = int(seconds % 60)
if hours > 0:
return f"{hours:02d}:{minutes:02d}:{secs:02d}"
return f"{minutes:02d}:{secs:02d}"
def merge_transcript_segments(segments: List[dict], max_duration: float = 60.0) -> List[dict]:
"""자막 세그먼트를 병합하여 더 읽기 쉬운 형태로 만듭니다.
Args:
segments: 자막 세그먼트 리스트 (각 세그먼트는 start, duration, text 포함)
max_duration: 병합할 최대 시간 간격 (초, 기본 60초)
Returns:
병합된 자막 세그먼트 리스트
"""
if not segments:
return []
merged = []
current_segment = {
'start': segments[0]['start'],
'text': segments[0]['text'],
'duration': segments[0].get('duration', 0)
}
for segment in segments[1:]:
if segment['start'] - current_segment['start'] < max_duration:
current_segment['text'] += ' ' + segment['text']
current_segment['duration'] = segment['start'] + segment.get('duration', 0) - current_segment['start']
else:
merged.append(current_segment)
current_segment = {
'start': segment['start'],
'text': segment['text'],
'duration': segment.get('duration', 0)
}
merged.append(current_segment)
return merged
def get_youtube_info(url: str) -> dict:
"""YouTube 동영상 정보 조회"""
try:
import yt_dlp
except ImportError:
return {'success': False, 'message': 'yt_dlp 패키지 없음'}
try:
with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True}) as ydl:
info = ydl.extract_info(url, download=False)
return {
'success': True,
'title': info.get('title', 'Unknown'),
'duration': info.get('duration', 0),
'uploader': info.get('uploader', 'Unknown'),
'view_count': info.get('view_count', 0),
}
except Exception as e:
return {'success': False, 'message': f'실패: {str(e)}'}
def extract_video_id(url: str) -> str:
"""YouTube URL에서 video_id 추출"""
# 이미 ID 형식인 경우
if re.match(r'^[a-zA-Z0-9_-]{11}$', url):
return url
patterns = [
r'(?:v=|/v/|youtu\.be/)([a-zA-Z0-9_-]{11})',
r'(?:embed/)([a-zA-Z0-9_-]{11})',
r'youtube\.com\/shorts\/([a-zA-Z0-9_-]{11})',
]
for pattern in patterns:
match = re.search(pattern, url)
if match:
return match.group(1)
return None
def list_available_transcripts(url: str) -> dict:
"""YouTube 동영상에서 사용 가능한 자막 언어 목록을 조회합니다.
Args:
url: YouTube URL 또는 video_id
Returns:
dict: {
'success': bool,
'video_id': str,
'manual_transcripts': list, # 수동 생성 자막 목록
'auto_transcripts': list, # 자동 생성 자막 목록
'message': str
}
"""
try:
from youtube_transcript_api import YouTubeTranscriptApi
except ImportError:
return {
'success': False,
'message': 'youtube-transcript-api 패키지가 필요합니다. pip install youtube-transcript-api'
}
video_id = extract_video_id(url)
if not video_id:
return {
'success': False,
'message': f'올바른 YouTube URL이 아닙니다: {url}'
}
try:
ytt_api = YouTubeTranscriptApi()
transcript_list = ytt_api.list(video_id)
manual_transcripts = []
auto_transcripts = []
for t in transcript_list:
info = {
'language': t.language,
'language_code': t.language_code,
'is_translatable': t.is_translatable
}
if t.is_generated:
auto_transcripts.append(info)
else:
manual_transcripts.append(info)
return {
'success': True,
'video_id': video_id,
'manual_transcripts': manual_transcripts,
'auto_transcripts': auto_transcripts,
'message': f'자막 언어 목록 조회 완료. 수동: {len(manual_transcripts)}개, 자동: {len(auto_transcripts)}개'
}
except Exception as e:
return {
'success': False,
'message': f'자막 목록 조회 실패: {str(e)}'
}
def get_youtube_transcript(
url: str,
languages: list = None,
include_timestamps: bool = False,
merge_segments: bool = False,
max_length: Optional[int] = None
) -> dict:
"""
YouTube 동영상의 자막/트랜스크립트를 가져옵니다.
Args:
url: YouTube URL 또는 video_id
languages: 선호 언어 목록 (예: ['ko', 'en']). None이면 자동 선택
include_timestamps: True면 타임스탬프 포함 형식으로 반환
merge_segments: True면 짧은 세그먼트를 60초 단위로 병합
max_length: 반환할 자막의 최대 문자 수 (None이면 제한 없음)
Returns:
dict: {
'success': bool,
'transcript': str, # 전체 자막 텍스트
'formatted_transcript': str, # 포맷팅된 자막 (타임스탬프 포함 시)
'segments': list, # 타임스탬프 포함 세그먼트
'language': str, # 사용된 언어
'title': str, # 영상 제목
'duration': int, # 영상 길이 (초)
'message': str
}
"""
try:
from youtube_transcript_api import YouTubeTranscriptApi
except ImportError:
return {
'success': False,
'message': 'youtube-transcript-api 패키지가 필요합니다. pip install youtube-transcript-api'
}
# video_id 추출
video_id = extract_video_id(url)
if not video_id:
return {
'success': False,
'message': f'올바른 YouTube URL이 아닙니다: {url}'
}
# 영상 정보 가져오기 (선택적)
video_info = get_youtube_info(url)
title = video_info.get('title', 'Unknown') if video_info.get('success') else 'Unknown'
duration = video_info.get('duration', 0) if video_info.get('success') else 0
try:
# 언어 우선순위 설정
if languages is None:
languages = ['ko', 'en', 'ja', 'zh-Hans', 'zh-Hant']
# youtube-transcript-api 1.2.x 새로운 API 사용
ytt_api = YouTubeTranscriptApi()
transcript_data = None
used_language = None
# 선호 언어 순서대로 시도
for lang in languages:
try:
transcript_data = ytt_api.fetch(video_id, languages=[lang])
used_language = lang
break
except Exception:
continue
# 선호 언어로 못 찾으면 아무 자막이나
if transcript_data is None:
try:
transcript_data = ytt_api.fetch(video_id)
used_language = 'auto'
except Exception as e:
return {
'success': False,
'message': f'자막을 찾을 수 없습니다: {str(e)}'
}
if not transcript_data:
return {
'success': False,
'message': '사용 가능한 자막이 없습니다.'
}
# 타임스탬프 포함 세그먼트
segments = [
{
'start': segment.start,
'duration': segment.duration,
'text': segment.text
}
for segment in transcript_data
]
# 세그먼트 병합 옵션 적용
if merge_segments:
segments = merge_transcript_segments(segments)
# 전체 텍스트로 합치기
full_text = ' '.join([s['text'] for s in segments])
full_text = re.sub(r'\s+', ' ', full_text).strip()
# 최대 길이 제한 적용
if max_length and len(full_text) > max_length:
full_text = full_text[:max_length] + "... (자막이 잘렸습니다)"
# 타임스탬프 포함 포맷팅
formatted_transcript = None
if include_timestamps:
formatted_lines = []
for segment in segments:
timestamp = format_timestamp(segment['start'])
text = segment['text'].strip()
formatted_lines.append(f"[{timestamp}] {text}")
formatted_transcript = '\n'.join(formatted_lines)
return {
'success': True,
'transcript': full_text,
'formatted_transcript': formatted_transcript,
'segments': segments,
'language': used_language,
'title': title,
'duration': duration,
'video_id': video_id,
'message': f'자막을 성공적으로 가져왔습니다. (언어: {used_language}, 세그먼트: {len(segments)}개)'
}
except Exception as e:
return {
'success': False,
'message': f'자막 가져오기 실패: {str(e)}'
}
def load_system_ai_config() -> dict:
"""시스템 AI 설정 로드"""
if os.path.exists(SYSTEM_AI_CONFIG_PATH):
try:
with open(SYSTEM_AI_CONFIG_PATH, 'r', encoding='utf-8') as f:
return json.load(f)
except:
pass
return {
"provider": "google",
"model": "gemini-2.0-flash",
"apiKey": ""
}
def get_summary_ai_client():
"""요약용 AI 클라이언트 반환 (시스템 AI 설정 사용)"""
config = load_system_ai_config()
provider = config.get("provider", "google")
model = config.get("model", "gemini-2.0-flash")
api_key = config.get("apiKey") or config.get("api_key", "")
# provider 이름 정규화
if provider in ["google", "gemini"]:
from google import genai
client = genai.Client(api_key=api_key)
return client, "gemini", model
elif provider == "openai":
import openai
client = openai.OpenAI(api_key=api_key)
return client, "openai", model
elif provider == "anthropic":
import anthropic
client = anthropic.Anthropic(api_key=api_key)
return client, "anthropic", model
else:
raise ValueError(f"Unknown provider: {provider}")
def summarize_youtube(
url: str,
summary_length: int = 3000,
languages: list = None
) -> Dict[str, Any]:
"""
YouTube 동영상을 AI로 요약하여 HTML 파일로 저장합니다.
Args:
url: YouTube URL 또는 video_id
summary_length: 요약 길이 (기본 3000자)
languages: 선호 언어 목록 (예: ['ko', 'en']). None이면 자동 선택
Returns:
dict: {
'success': bool,
'file_path': str, # 생성된 HTML 파일 경로
'title': str, # 영상 제목
'duration': int, # 영상 길이 (초)
'message': str
}
"""
print(f"\n📺 YouTube 영상 요약 시작: {url}")
# 1. 자막 가져오기
print("[1/3] 자막 가져오는 중...")
transcript_result = get_youtube_transcript(url, languages=languages)
if not transcript_result.get('success'):
return {
'success': False,
'message': f"자막 가져오기 실패: {transcript_result.get('message')}"
}
transcript = transcript_result.get('transcript', '')
title = transcript_result.get('title', 'Unknown')
duration = transcript_result.get('duration', 0)
video_id = transcript_result.get('video_id', '')
language = transcript_result.get('language', 'auto')
print(f" ✓ 자막 가져오기 완료 (언어: {language}, {len(transcript)}자)")
# 2. AI로 요약 생성
print("[2/3] AI 요약 생성 중...")
summary_prompt = f"""다음은 YouTube 동영상의 자막입니다. 이 내용을 {summary_length}자 내외로 상세하게 요약해주세요.
## 요약 형식
### 영상 개요
- 영상의 핵심 주제와 목적
### 주요 내용
- 영상에서 다루는 핵심 포인트들을 구조적으로 정리
- 중요한 개념, 주장, 근거 포함
- 소제목을 사용해 구분
### 핵심 인사이트
- 이 영상에서 얻을 수 있는 가장 중요한 통찰 3가지
### 결론
- 영상의 결론 및 시사점
톤: 정보 전달에 충실하되 읽기 쉽게
분량: 약 {summary_length}자
=== 영상 정보 ===
제목: {title}
길이: {duration // 60}분 {duration % 60}초
=== 자막 내용 ===
{transcript[:50000]}
"""
try:
ai_result = get_summary_ai_client()
if ai_result[1] == "gemini":
client, _, model_name = ai_result
response = client.models.generate_content(
model=model_name,
contents=summary_prompt
)
summary_content = response.text
elif ai_result[1] == "openai":
client, _, model_name = ai_result
response = client.chat.completions.create(
model=model_name,
messages=[{"role": "user", "content": summary_prompt}]
)
summary_content = response.choices[0].message.content
elif ai_result[1] == "anthropic":
client, _, model_name = ai_result
response = client.messages.create(
model=model_name,
max_tokens=8192,
messages=[{"role": "user", "content": summary_prompt}]
)
summary_content = response.content[0].text
print(f" ✓ AI 요약 완료 ({len(summary_content)}자)")
except Exception as ai_err:
return {
'success': False,
'message': f"AI 요약 실패: {str(ai_err)}"
}
# 3. HTML 파일로 저장
print("[3/3] HTML 파일 생성 중...")
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
today_str = datetime.now().strftime("%Y년 %m월 %d일")
# 제목에서 파일명으로 쓸 수 없는 문자 제거
safe_title = re.sub(r'[^\w가-힣\s-]', '', title)[:30].strip()
markdown_content = f"""# {title}
**영상 링크**: [YouTube에서 보기](https://youtube.com/watch?v={video_id})
**영상 길이**: {duration // 60}분 {duration % 60}초
**요약 일시**: {today_str}
**요약 길이**: 약 {summary_length}자
---
{summary_content}
---
## 📊 요약 정보
- **원본 자막 길이**: {len(transcript)}자
- **요약 길이**: {len(summary_content)}자
- **요약 언어**: {language}
- **생성 시각**: {datetime.now().strftime('%Y년 %m월 %d일 %H시 %M분')}
"""
# HTML 변환 및 저장
os.makedirs(OUTPUTS_DIR, exist_ok=True)
html_content = markdown_to_html(markdown_content, f"YouTube 요약: {title}", today_str, doc_type="report")
html_filename = f"youtube_summary_{safe_title}_{timestamp}.html"
html_filepath = os.path.join(OUTPUTS_DIR, html_filename)
with open(html_filepath, 'w', encoding='utf-8') as f:
f.write(html_content)
print(f"💾 HTML 저장: {html_filename}")
print(f"✅ YouTube 요약 완료!\n")
return {
'success': True,
'file_path': html_filepath,
'title': title,
'duration': duration,
'summary_length': len(summary_content),
'message': f'YouTube 영상 요약이 완료되었습니다. 파일: {html_filepath}'
}
# 도구 정의
YOUTUBE_TOOLS = [
{
"name": "download_youtube_music",
"description": "YouTube에서 음악을 MP3로 다운로드합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL"},
"filename": {"type": "string", "description": "파일명"}
},
"required": ["url"]
}
},
{
"name": "get_youtube_info",
"description": "YouTube 동영상 정보를 조회합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL"}
},
"required": ["url"]
}
},
{
"name": "get_youtube_transcript",
"description": "YouTube 동영상의 자막/트랜스크립트를 가져옵니다. 영상 내용을 텍스트로 추출할 때 사용합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL 또는 video_id"},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 언어 코드 목록 (예: ['ko', 'en']). 생략시 자동 선택"
},
"include_timestamps": {
"type": "boolean",
"description": "True면 [MM:SS] 형식의 타임스탬프 포함. 기본값: False"
},
"merge_segments": {
"type": "boolean",
"description": "True면 짧은 자막을 60초 단위로 병합하여 가독성 향상. 기본값: False"
},
"max_length": {
"type": "integer",
"description": "반환할 자막의 최대 문자 수. 요약용으로 사용 시 유용. 생략시 제한 없음"
}
},
"required": ["url"]
}
},
{
"name": "list_available_transcripts",
"description": "YouTube 동영상에서 사용 가능한 자막 언어 목록을 조회합니다. 어떤 언어 자막이 있는지 미리 확인할 때 유용합니다.",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL 또는 video_id"}
},
"required": ["url"]
}
},
{
"name": "summarize_youtube",
"description": "YouTube 동영상을 AI로 요약하여 HTML 파일로 저장합니다. 자막을 가져와서 AI가 지정된 길이로 요약하고, 결과를 HTML 파일로 저장한 뒤 파일 경로를 반환합니다.",
"uses_ai": True,
"ai_config_key": "youtube",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL 또는 video_id"},
"summary_length": {
"type": "integer",
"description": "요약 길이 (기본 3000자). 예: 1000, 2000, 3000, 5000"
},
"languages": {
"type": "array",
"items": {"type": "string"},
"description": "선호 언어 코드 목록 (예: ['ko', 'en']). 생략시 자동 선택"
}
},
"required": ["url"]
}
}
]
===FILE:README.md===
# YouTube 도구
## 목적
에이전트가 YouTube 동영상을 다루는 능력을 제공합니다.
음악 다운로드, 정보 조회, 자막 추출, AI 요약 등을 할 수 있습니다.
## 이 도구가 제공하는 것
- **음악 다운로드**: YouTube 영상에서 MP3 추출
- **정보 조회**: 제목, 길이, 조회수, 설명 등
- **자막 추출**: 자동 생성 또는 수동 자막 텍스트화
- **AI 요약**: 자막 기반으로 영상 내용 요약
## 설치 시 필요한 변경사항
### 1. 도구 함수 구현
에이전트가 호출할 수 있는 도구 함수들을 구현해야 합니다.
**download_youtube_music(url, output_path)**
- YouTube URL에서 음악만 추출
- MP3 또는 M4A 형식으로 저장
- 파일 경로 반환
**get_youtube_info(url)**
- 영상 메타데이터 조회
- 제목, 채널, 길이, 조회수, 설명 등 반환
**get_youtube_transcript(url, language)**
- 자막 텍스트 추출
- 언어 지정 가능 (ko, en 등)
- 시간 정보 포함/제외 선택
**list_available_transcripts(url)**
- 해당 영상에서 사용 가능한 자막 언어 목록
**summarize_youtube(url, ai_config)**
- 자막을 가져와서 AI로 요약
- 결과를 HTML 파일로 저장
### 2. 도구 정의
AI가 도구를 인식할 수 있도록 정의해야 합니다.
```json
{
"name": "download_youtube_music",
"description": "YouTube 영상에서 음악을 MP3로 다운로드합니다",
"input_schema": {
"type": "object",
"properties": {
"url": {"type": "string", "description": "YouTube URL"},
"output_path": {"type": "string", "description": "저장 경로 (선택)"}
},
"required": ["url"]
}
}
```
### 3. 에이전트 연동
설치된 도구를 에이전트가 사용할 수 있어야 합니다.
- 프로젝트 설정에서 이 도구를 에이전트에 배정
- AI 호출 시 도구 정의 포함
- tool_use 응답 처리
### 4. 출력 관리
다운로드된 파일과 생성된 결과를 관리해야 합니다.
- 기본 저장 경로 설정
- 파일명 중복 처리
- 용량 관리 (선택)
## 외부 의존성
이 도구는 외부 프로그램이 필요합니다.
**yt-dlp**: YouTube 다운로더
```bash
pip install yt-dlp
```
**ffmpeg**: 오디오 변환
```bash
# macOS
brew install ffmpeg
# Ubuntu
sudo apt install ffmpeg
# Windows
# ffmpeg.org에서 다운로드 후 PATH에 추가
```
**youtube-transcript-api**: 자막 추출
```bash
pip install youtube-transcript-api
```
## 참고 구현
이 폴더의 `tool_youtube.py`는 Python 기반 구현 예시입니다.
```
tool_youtube.py
├── download_youtube_music()
├── get_youtube_info()
├── get_youtube_transcript()
├── list_available_transcripts()
├── summarize_youtube()
└── YOUTUBE_TOOLS (도구 정의)
```
이 코드를 그대로 사용하지 말고, 현재 시스템에 맞게 구현하세요.
## 법적 고려사항
- 저작권이 있는 콘텐츠 다운로드 시 주의
- 개인 사용 목적으로만 사용 권장
- YouTube 이용약관 확인
## 설치 완료 확인
- [ ] 에이전트가 도구를 호출할 수 있음
- [ ] YouTube URL에서 음악 다운로드 가능
- [ ] 영상 정보 조회 가능
- [ ] 자막 추출 가능
- [ ] AI 요약 생성 가능
===PACKAGE_END===
#indiebizOS-package