Ver3.0 ๐ง Claude API๋ก ์ด๋ฉ์ผ ์ฒจ๋ถํ์ผ ์๋์์ฝ ์์คํ ๋ง๋ค๊ธฐ: ์ ๋ฌด ํจ์จ 200% ๋์ด๋ AI ์๋ํ ๊ฐ์ด๋

๐ง Claude API๋ก ์ด๋ฉ์ผ ์ฒจ๋ถํ์ผ ์๋์์ฝ ์์คํ ๋ง๋ค๊ธฐ: ์ ๋ฌด ํจ์จ 200% ๋์ด๋ AI ์๋ํ ๊ฐ์ด๋
๋งค์ผ ์์ด๋ ์ด๋ฉ์ผ ์ฒจ๋ถํ์ผ, ์ด์ AI๊ฐ ์๋์ผ๋ก ์์ฝํด๋๋ฆฝ๋๋ค ๐
๐ ๋งค์ผ ์์นจ ์ถ๊ทผํ๋ฉด ์์ฌ์๋ ์์ญ ํต์ ์ด๋ฉ์ผ๋ค... ๊ทธ๋ฆฌ๊ณ ๊ฐ๊ฐ์ ์ฒจ๋ถ๋ PDF, ์๋ ๋ฌธ์, ์์
ํ์ผ๋ค. ํ๋ํ๋ ์ด์ด๋ณด๊ณ ๋ด์ฉ์ ํ์
ํ๋ ๋ฐ๋ง 1~2์๊ฐ์ด ํ์ฉ ์ง๋๊ฐ์ฃ ?
์์ฆ ๊ฐ์ AI ์๋์ ์ด๋ฐ ๋ฐ๋ณต ์์
์ ์์ผ๋ก ํ๊ณ ์๋ค๋ฉด ์ ๋ง ์๊น์ด ์๊ฐ ๋ญ๋น์์! ๐ฑ
์ค๋์ Claude API๋ฅผ ํ์ฉํด์ ์ด๋ฉ์ผ ์ฒจ๋ถํ์ผ์ ์๋์ผ๋ก ์ฝ๊ณ ํต์ฌ ๋ด์ฉ๋ง ์์ ๋ฝ์์ฃผ๋ ์์คํ
์ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์. ํ๋ก๊ทธ๋๋ฐ ๊ฒฝํ์ด ์กฐ๊ธ๋ง ์๋ค๋ฉด ๋๊ตฌ๋ ๋ฐ๋ผํ ์ ์๋๋ก ์น๊ตฌ์๊ฒ ์ค๋ช
ํ๋ฏ ์ฝ๊ฒ ํ์ด๋๋ฆด๊ฒ์! ๐ฏ
๐ค ์ Claude API์ธ๊ฐ์?
AI ์๋ํ ์์คํ
์ ๋ง๋ค ๋ ์ ํ์ง๋ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ด์. ChatGPT API, Google Bard, ๊ทธ๋ฆฌ๊ณ Claude API๊น์ง. ๊ทธ๋ฐ๋ฐ ์ ํํ Claude์ผ๊น์?
์ค์ ๋ก ์ฌ๋ฌ ํ๋ก์ ํธ์์ ํ
์คํธํด๋ณธ ๊ฒฐ๊ณผ, ๋ฌธ์ ์ฒ๋ฆฌ์ ์์ฝ ์์
์์๋ Claude๊ฐ ์ ๋ง ํ์ํ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ์ด์. ํนํ ๊ธด ๋ฌธ์๋ฅผ ์ฝ๊ณ ํต์ฌ์ ์ถ์ถํ๋ ๋ฅ๋ ฅ์ด ๋ฐ์ด๋์ฃ .
โจ Claude API์ ๊ฐ์
1๏ธโฃ ๊ธด ๋ฌธ๋งฅ ์ดํด ๋ฅ๋ ฅ (์ต๋ 200K ํ ํฐ)
Claude 3 ๋ชจ๋ธ์ ์ต๋ 200,000๊ฐ์ ํ ํฐ์ ํ ๋ฒ์ ์ฒ๋ฆฌํ ์ ์์ด์. ์ด๊ฒ ์ผ๋ง๋ ๋๋จํ ๊ฑฐ๋๋ฉด, ์ผ๋ฐ์ ์ธ ์ฑ
ํ ๊ถ ๋ถ๋(์ฝ 500ํ์ด์ง)์ ํต์งธ๋ก ์ฝ๊ณ ์ดํดํ ์ ์๋ค๋ ๋ป์ด์์! ๐
PDF ๋ณด๊ณ ์๊ฐ 50ํ์ด์ง๋ 100ํ์ด์ง๋ ํ ๋ฒ์ ์ญ ์ฝ๊ณ ์์ฝํ ์ ์์ฃ .
2๏ธโฃ ์ ํํ ์ ๋ณด ์ถ์ถ
Claude๋ ํ๊ฐ(Hallucination) ํ์์ด ์๋์ ์ผ๋ก ์ ์ด์. ์ฆ, ์๋ ๋ด์ฉ์ ์ง์ด๋ด๋ ๊ฒฝ์ฐ๊ฐ ์ ๋ค๋ ๊ฑฐ์ฃ . ๋น์ฆ๋์ค ๋ฌธ์๋ฅผ ๋ค๋ฃฐ ๋๋ ์ด๊ฒ ์ ๋ง ์ค์ํด์. ์๋ชป๋ ์ ๋ณด๋ก ์์ฌ๊ฒฐ์ ์ ํ๋ฉด ํฐ์ผ๋๋๊น์! ๐ฐ
3๏ธโฃ ๊ตฌ์กฐํ๋ ์ถ๋ ฅ
์์ฝ ๊ฒฐ๊ณผ๋ฅผ JSON, ๋งํฌ๋ค์ด, ํ ํ์ ๋ฑ ์ํ๋ ํํ๋ก ๊น๋ํ๊ฒ ์ ๋ฆฌํด์ค์. ์ดํ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ ๋ณด๊ณ ์ ์์ฑ์ด ํจ์ฌ ์์ํด์ง์ฃ .
4๏ธโฃ ํฉ๋ฆฌ์ ์ธ ๊ฐ๊ฒฉ
Claude 3 Haiku ๋ชจ๋ธ์ 100๋ง ํ ํฐ๋น $0.25๋ก ์ ๋ง ์ ๋ ดํด์. ๋งค์ผ ์์ญ ๊ฐ์ ๋ฌธ์๋ฅผ ์ฒ๋ฆฌํด๋ ์ ๋น์ฉ์ด ๋ช ๋ฌ๋ฌ ์์ค์ด์์. ๐ฐ
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ AI ์๋ํ ๊ด๋ จ ์ฌ๋ฅ์ ๊ฑฐ๋ํ๋ ๋ถ๋ค์ด ๋ง์๋ฐ์, Claude API๋ฅผ ํ์ฉํ ์๋ฃจ์ ์ ํนํ ๋ฌธ์ ์ฒ๋ฆฌ๊ฐ ๋ง์ ๊ธฐ์ ๋ค์๊ฒ ์ธ๊ธฐ๊ฐ ๋ง์์. ์ค์ ๋ก ๋ฒ๋ฅ , ๊ธ์ต, ์ปจ์คํ ๋ถ์ผ์์ ๋ง์ด ์ฐพ์ผ์๋๋ผ๊ณ ์! ๐ข
๐๏ธ ์์คํ ์ํคํ ์ฒ ์ค๊ณํ๊ธฐ
๋ณธ๊ฒฉ์ ์ผ๋ก ์ฝ๋ฉ์ ๋ค์ด๊ฐ๊ธฐ ์ ์, ์ ์ฒด ์์คํ ์ด ์ด๋ป๊ฒ ๋์ํ ์ง ์ค๊ณ๋ถํฐ ํด๋ณผ๊ฒ์. ๊ฑด์ถํ ๋ ์ค๊ณ๋๊ฐ ํ์ํ๋ฏ, ํ๋ก๊ทธ๋จ๋ ๋ง์ฐฌ๊ฐ์ง์์! ๐
๐ ์ฒ๋ฆฌ ํ๋ฆ ์์ธ ์ค๋ช
IMAP ํ๋กํ ์ฝ์ ์ฌ์ฉํด์ ์ด๋ฉ์ผ ์๋ฒ์ ์ฃผ๊ธฐ์ ์ผ๋ก ์ ์ํด์. ์๋ก์ด ์ด๋ฉ์ผ์ด ์๋์ง ์ฒดํฌํ๊ณ , ์ฒจ๋ถํ์ผ์ด ์๋ ๋ฉ์ผ๋ง ํํฐ๋งํ์ฃ . ๋ณดํต 5๋ถ~10๋ถ ๊ฐ๊ฒฉ์ผ๋ก ์ฒดํฌํ๋ฉด ์ ๋นํด์.
์ฒจ๋ถํ์ผ์ ์์ ํด๋์ ๋ค์ด๋ก๋ํ๊ณ , ํ์ผ ํ์ฅ์๋ฅผ ํ์ธํด์. PDF, DOCX, XLSX, TXT ๋ฑ ์ง์ํ๋ ํ์์ธ์ง ์ฒดํฌํ๊ณ , ํ์ผ ํฌ๊ธฐ๋ ํ์ธํด์. (๋๋ฌด ํฌ๋ฉด ์ฒ๋ฆฌ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋๊น์!)
๊ฐ ํ์ผ ํ์์ ๋ง๋ ํ์(Parser)๋ฅผ ์ฌ์ฉํด์ ํ ์คํธ๋ฅผ ์ถ์ถํด์. PDF๋ PyPDF2๋ pdfplumber, ์๋ ๋ฌธ์๋ python-docx ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฃ . ์ด๋ฏธ์ง๊ฐ ํฌํจ๋ PDF๋ OCR(๊ดํ ๋ฌธ์ ์ธ์)๋ ํ์ํ ์ ์์ด์.
์ถ์ถํ ํ ์คํธ๋ฅผ Claude API์ ์ ์กํ๊ณ , ์์ฝ์ ์์ฒญํด์. ์ด๋ ํ๋กฌํํธ ์์ง๋์ด๋ง์ด ์ ๋ง ์ค์ํ๋ฐ, ์ด๋ค ํ์์ผ๋ก ์์ฝํ ์ง, ์ด๋ค ์ ๋ณด๋ฅผ ์ค์ ์ ์ผ๋ก ์ถ์ถํ ์ง ๋ช ํํ๊ฒ ์ง์ํด์ผ ํด์.
์์ฝ๋ ๋ด์ฉ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ๊ณ , ์ฌ์ฉ์์๊ฒ ์๋ฆผ์ ๋ณด๋ด์. ์ฌ๋(Slack), ์ด๋ฉ์ผ, ์นด์นด์คํก ๋ฑ ์ํ๋ ์ฑ๋๋ก ์ ์กํ ์ ์์ฃ . ๋์๋ณด๋๋ฅผ ๋ง๋ค์ด์ ์น์์ ํ์ธํ ์๋ ์๊ณ ์!
๐ ๏ธ ๊ฐ๋ฐ ํ๊ฒฝ ์ธํ ํ๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฝ๋ฉ์ ์์ํด๋ณผ๊น์? ๋จผ์ ๊ฐ๋ฐ ํ๊ฒฝ๋ถํฐ ์ค๋นํด์ผ๊ฒ ์ฃ ! ๐
๐ฆ ํ์ํ ๋๊ตฌ๋ค
| ๋๊ตฌ | ์ฉ๋ | ์ถ์ฒ ๋ฒ์ |
|---|---|---|
| Python | ๋ฉ์ธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด | 3.9 ์ด์ |
| Claude API Key | AI ์์ฝ ์๋น์ค | Anthropic ๊ณ์ ํ์ |
| ์ด๋ฉ์ผ ๊ณ์ | IMAP ์ ๊ทผ ๊ฐ๋ฅํ ๊ณ์ | Gmail, Outlook ๋ฑ |
| VS Code | ์ฝ๋ ์๋ํฐ | ์ต์ ๋ฒ์ |
| Git | ๋ฒ์ ๊ด๋ฆฌ | ์ต์ ๋ฒ์ |
๐ Python ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
ํฐ๋ฏธ๋์ ์ด๊ณ ๋ค์ ๋ช ๋ น์ด๋ค์ ์ฐจ๋ก๋๋ก ์คํํด์ฃผ์ธ์. ๊ฐ์ํ๊ฒฝ์ ๋ง๋ค์ด์ ์์ ํ๋ ๊ฒ ์ข์์! ๐
# ๊ฐ์ํ๊ฒฝ ์์ฑ
python -m venv email_summarizer_env
# ๊ฐ์ํ๊ฒฝ ํ์ฑํ (Windows)
email_summarizer_env\Scripts\activate
# ๊ฐ์ํ๊ฒฝ ํ์ฑํ (Mac/Linux)
source email_summarizer_env/bin/activate
# ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
pip install anthropic
pip install imaplib2
pip install email
pip install PyPDF2
pip install pdfplumber
pip install python-docx
pip install openpyxl
pip install python-dotenv
pip install schedule
pip install requests
๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ๋ญํ๋ ๊ฑด์ง ๊ฐ๋จํ ์ค๋ช ํด๋๋ฆด๊ฒ์! ๐
anthropic - Claude API๋ฅผ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๊ฒ ํด์ฃผ๋ ๊ณต์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์. API ํธ์ถ, ์คํธ๋ฆฌ๋ฐ, ์๋ฌ ์ฒ๋ฆฌ ๋ฑ์ ๊ฐํธํ๊ฒ ํ ์ ์์ฃ .
imaplib2 - ์ด๋ฉ์ผ ์๋ฒ์ ์ ์ํด์ ๋ฉ์ผ์ ์ฝ์ด์ค๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์. IMAP ํ๋กํ ์ฝ์ ์ง์ํ์ฃ .
PyPDF2 / pdfplumber - PDF ํ์ผ์์ ํ ์คํธ๋ฅผ ์ถ์ถํด์. PyPDF2๋ ๊ธฐ๋ณธ์ ์ธ ์ถ์ถ, pdfplumber๋ ํ๋ ๋ณต์กํ ๋ ์ด์์๋ ์ฒ๋ฆฌํ ์ ์์ด์.
python-docx - ์๋ ๋ฌธ์(.docx)๋ฅผ ์ฝ๊ณ ์ธ ์ ์๊ฒ ํด์ค์. ํ ์คํธ๋ฟ๋ง ์๋๋ผ ํ, ์ด๋ฏธ์ง ์ ๋ณด๋ ์ถ์ถ ๊ฐ๋ฅํด์.
openpyxl - ์์ ํ์ผ(.xlsx)์ ๋ค๋ฃจ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์. ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ ํ ์คํธ๋ก ๋ณํํ ์ ์์ฃ .
python-dotenv - API ํค ๊ฐ์ ๋ฏผ๊ฐํ ์ ๋ณด๋ฅผ .env ํ์ผ์ ์์ ํ๊ฒ ์ ์ฅํ๊ณ ๋ถ๋ฌ์ฌ ์ ์์ด์. ๋ณด์์ ํ์! ๐
schedule - ์ฃผ๊ธฐ์ ์ผ๋ก ์์ ์ ์คํํ ์ ์๊ฒ ์ค์ผ์ค๋งํด์ฃผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์. ํฌ๋ก (Cron)๋ณด๋ค ์ฌ์ฉํ๊ธฐ ์ฌ์์.
๐ป ํต์ฌ ์ฝ๋ ๊ตฌํํ๊ธฐ
๋๋์ด ์ฝ๋ฉ ์๊ฐ์ด์์! ํ๋์ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ง๋ค์ด๋ณผ๊ฒ์. ์ ์ฒด ์ฝ๋๋ฅผ ํ ๋ฒ์ ๋ณด๋ฉด ๋ณต์กํด ๋ณด์ด์ง๋ง, ๊ธฐ๋ฅ๋ณ๋ก ๋๋ ์ ๋ณด๋ฉด ์๊ฐ๋ณด๋ค ๊ฐ๋จํด์. ๐
1๏ธโฃ ํ๊ฒฝ ์ค์ ํ์ผ ๋ง๋ค๊ธฐ
๋จผ์ ํ๋ก์ ํธ ๋ฃจํธ ํด๋์ .env ํ์ผ์ ๋ง๋ค์ด์ฃผ์ธ์. ์ฌ๊ธฐ์ API ํค์ ์ด๋ฉ์ผ ์ ๋ณด๋ฅผ ์ ์ฅํ ๊ฑฐ์์.
# .env ํ์ผ
CLAUDE_API_KEY=your_claude_api_key_here
EMAIL_ADDRESS=your_email@gmail.com
EMAIL_PASSWORD=your_app_password_here
IMAP_SERVER=imap.gmail.com
IMAP_PORT=993
2๏ธโฃ ์ด๋ฉ์ผ ์ฐ๊ฒฐ ๋ฐ ์ฒจ๋ถํ์ผ ๋ค์ด๋ก๋
์ด๋ฉ์ผ ์๋ฒ์ ์ ์ํด์ ์ ๋ฉ์ผ์ ํ์ธํ๊ณ ์ฒจ๋ถํ์ผ์ ๋ค์ด๋ก๋ํ๋ ์ฝ๋์์. ์ด ๋ถ๋ถ์ด ์์คํ ์ ์์์ ์ด์ฃ ! ๐ฌ
import imaplib
import email
from email.header import decode_header
import os
from dotenv import load_dotenv
# ํ๊ฒฝ ๋ณ์ ๋ก๋
load_dotenv()
class EmailFetcher:
def __init__(self):
self.email_address = os.getenv('EMAIL_ADDRESS')
self.email_password = os.getenv('EMAIL_PASSWORD')
self.imap_server = os.getenv('IMAP_SERVER')
self.imap_port = int(os.getenv('IMAP_PORT'))
self.mail = None
def connect(self):
"""์ด๋ฉ์ผ ์๋ฒ์ ์ฐ๊ฒฐ"""
try:
self.mail = imaplib.IMAP4_SSL(self.imap_server, self.imap_port)
self.mail.login(self.email_address, self.email_password)
print("โ
์ด๋ฉ์ผ ์๋ฒ ์ฐ๊ฒฐ ์ฑ๊ณต!")
return True
except Exception as e:
print(f"โ ์ฐ๊ฒฐ ์คํจ: {e}")
return False
def fetch_unread_emails(self):
"""์ฝ์ง ์์ ์ด๋ฉ์ผ ๊ฐ์ ธ์ค๊ธฐ"""
self.mail.select('inbox')
# ์ฝ์ง ์์ ๋ฉ์ผ ๊ฒ์
status, messages = self.mail.search(None, 'UNSEEN')
email_ids = messages[0].split()
print(f"๐ง ์๋ก์ด ์ด๋ฉ์ผ {len(email_ids)}๊ฐ ๋ฐ๊ฒฌ!")
return email_ids
def download_attachments(self, email_id, download_folder='attachments'):
"""์ฒจ๋ถํ์ผ ๋ค์ด๋ก๋"""
if not os.path.exists(download_folder):
os.makedirs(download_folder)
status, msg_data = self.mail.fetch(email_id, '(RFC822)')
email_body = msg_data[0][1]
message = email.message_from_bytes(email_body)
# ์ด๋ฉ์ผ ์ ๋ชฉ ์ถ์ถ
subject = decode_header(message['Subject'])[0][0]
if isinstance(subject, bytes):
subject = subject.decode()
print(f"๐จ ์ฒ๋ฆฌ ์ค: {subject}")
attachments = []
# ์ฒจ๋ถํ์ผ ์ฐพ๊ธฐ
for part in message.walk():
if part.get_content_maintype() == 'multipart':
continue
if part.get('Content-Disposition') is None:
continue
filename = part.get_filename()
if filename:
# ํ์ผ๋ช
๋์ฝ๋ฉ
if decode_header(filename)[0][1]:
filename = decode_header(filename)[0][0].decode(
decode_header(filename)[0][1]
)
# ์ง์ํ๋ ํ์ผ ํ์๋ง ๋ค์ด๋ก๋
supported_extensions = ['.pdf', '.docx', '.xlsx', '.txt']
if any(filename.lower().endswith(ext) for ext in supported_extensions):
filepath = os.path.join(download_folder, filename)
# ํ์ผ ์ ์ฅ
with open(filepath, 'wb') as f:
f.write(part.get_payload(decode=True))
attachments.append({
'filename': filename,
'filepath': filepath,
'subject': subject
})
print(f"๐พ ๋ค์ด๋ก๋ ์๋ฃ: {filename}")
return attachments
def disconnect(self):
"""์ฐ๊ฒฐ ์ข
๋ฃ"""
if self.mail:
self.mail.close()
self.mail.logout()
print("๐ ์ด๋ฉ์ผ ์๋ฒ ์ฐ๊ฒฐ ์ข
๋ฃ")
์ด ์ฝ๋์ ํต์ฌ์ IMAP ํ๋กํ ์ฝ์ ์ฌ์ฉํด์ ์ด๋ฉ์ผ ์๋ฒ์ ์ ์ํ๊ณ , ์ฝ์ง ์์ ๋ฉ์ผ๋ง ํํฐ๋งํ ๋ค์, ์ฒจ๋ถํ์ผ์ ๋ก์ปฌ์ ์ ์ฅํ๋ ๊ฑฐ์์.
ํนํ ์ฃผ์ํ ์ ์ ์ด๋ฉ์ผ ์ ๋ชฉ์ด๋ ํ์ผ๋ช
์ด ํ๊ธ์ผ ๊ฒฝ์ฐ ์ธ์ฝ๋ฉ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์์ด์ decode_header ํจ์๋ก ์ ๋๋ก ๋์ฝ๋ฉํด์ค์ผ ํด์! ๐ค
3๏ธโฃ ํ์ผ ํ ์คํธ ์ถ์ถ๊ธฐ
๋ค์ด๋ก๋ํ ํ์ผ๋ค์์ ํ ์คํธ๋ฅผ ์ถ์ถํ๋ ๋ถ๋ถ์ด์์. ํ์ผ ํ์๋ง๋ค ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์ฌ์ฉํด์ผ ํ์ฃ ! ๐
import PyPDF2
import pdfplumber
from docx import Document
import openpyxl
class FileParser:
@staticmethod
def extract_text_from_pdf(filepath):
"""PDF์์ ํ
์คํธ ์ถ์ถ"""
text = ""
try:
# ๋จผ์ PyPDF2๋ก ์๋
with open(filepath, 'rb') as file:
pdf_reader = PyPDF2.PdfReader(file)
for page in pdf_reader.pages:
text += page.extract_text()
# ํ
์คํธ๊ฐ ๊ฑฐ์ ์์ผ๋ฉด pdfplumber๋ก ์ฌ์๋
if len(text.strip()) < 100:
with pdfplumber.open(filepath) as pdf:
for page in pdf.pages:
page_text = page.extract_text()
if page_text:
text += page_text
print(f"โ
PDF ํ
์คํธ ์ถ์ถ ์๋ฃ: {len(text)} ๊ธ์")
return text
except Exception as e:
print(f"โ PDF ์ถ์ถ ์คํจ: {e}")
return ""
@staticmethod
def extract_text_from_docx(filepath):
"""์๋ ๋ฌธ์์์ ํ
์คํธ ์ถ์ถ"""
try:
doc = Document(filepath)
text = ""
# ๋ณธ๋ฌธ ํ
์คํธ
for paragraph in doc.paragraphs:
text += paragraph.text + "\n"
# ํ ๋ด์ฉ๋ ์ถ์ถ
for table in doc.tables:
for row in table.rows:
for cell in row.cells:
text += cell.text + "\t"
text += "\n"
print(f"โ
DOCX ํ
์คํธ ์ถ์ถ ์๋ฃ: {len(text)} ๊ธ์")
return text
except Exception as e:
print(f"โ DOCX ์ถ์ถ ์คํจ: {e}")
return ""
@staticmethod
def extract_text_from_xlsx(filepath):
"""์์
์์ ํ
์คํธ ์ถ์ถ"""
try:
workbook = openpyxl.load_workbook(filepath)
text = ""
for sheet_name in workbook.sheetnames:
sheet = workbook[sheet_name]
text += f"\n=== {sheet_name} ===\n"
for row in sheet.iter_rows(values_only=True):
row_text = "\t".join([str(cell) if cell else "" for cell in row])
text += row_text + "\n"
print(f"โ
XLSX ํ
์คํธ ์ถ์ถ ์๋ฃ: {len(text)} ๊ธ์")
return text
except Exception as e:
print(f"โ XLSX ์ถ์ถ ์คํจ: {e}")
return ""
@staticmethod
def extract_text_from_txt(filepath):
"""ํ
์คํธ ํ์ผ ์ฝ๊ธฐ"""
try:
with open(filepath, 'r', encoding='utf-8') as file:
text = file.read()
print(f"โ
TXT ํ
์คํธ ์ฝ๊ธฐ ์๋ฃ: {len(text)} ๊ธ์")
return text
except UnicodeDecodeError:
# UTF-8 ์คํจ์ ๋ค๋ฅธ ์ธ์ฝ๋ฉ ์๋
try:
with open(filepath, 'r', encoding='cp949') as file:
text = file.read()
return text
except:
print("โ TXT ์ฝ๊ธฐ ์คํจ: ์ธ์ฝ๋ฉ ๋ฌธ์ ")
return ""
except Exception as e:
print(f"โ TXT ์ฝ๊ธฐ ์คํจ: {e}")
return ""
@staticmethod
def parse_file(filepath):
"""ํ์ผ ํ์์ ๋ง๊ฒ ํ
์คํธ ์ถ์ถ"""
extension = os.path.splitext(filepath)[1].lower()
if extension == '.pdf':
return FileParser.extract_text_from_pdf(filepath)
elif extension == '.docx':
return FileParser.extract_text_from_docx(filepath)
elif extension == '.xlsx':
return FileParser.extract_text_from_xlsx(filepath)
elif extension == '.txt':
return FileParser.extract_text_from_txt(filepath)
else:
print(f"โ ๏ธ ์ง์ํ์ง ์๋ ํ์ผ ํ์: {extension}")
return ""
ํ์ผ ํ์ฑ์์ ๊ฐ์ฅ ๊น๋ค๋ก์ด ๊ฒ PDF์์. PDF๋ ๋ด๋ถ ๊ตฌ์กฐ๊ฐ ๋ณต์กํด์ ํ ์คํธ ์ถ์ถ์ด ์ ์ ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง๊ฑฐ๋ ์. ๊ทธ๋์ PyPDF2๋ก ๋จผ์ ์๋ํ๊ณ , ๊ฒฐ๊ณผ๊ฐ ๋ถ์คํ๋ฉด pdfplumber๋ก ์ฌ์๋ํ๋ ์ ๋ต์ ์ฌ์ฉํ์ด์! ๐ฏ
4๏ธโฃ Claude API ์์ฝ ์์ง
์ด์ ํต์ฌ ์ค์ ํต์ฌ! Claude API๋ฅผ ํธ์ถํด์ ํ ์คํธ๋ฅผ ์์ฝํ๋ ๋ถ๋ถ์ด์์. ์ฌ๊ธฐ์ ํ๋กฌํํธ ์์ง๋์ด๋ง์ด ์ ๋ง ์ค์ํด์! ๐ค
from anthropic import Anthropic
import os
class ClaudeSummarizer:
def __init__(self):
self.api_key = os.getenv('CLAUDE_API_KEY')
self.client = Anthropic(api_key=self.api_key)
self.model = "claude-3-haiku-20240307" # ๋น ๋ฅด๊ณ ์ ๋ ดํ ๋ชจ๋ธ
def summarize(self, text, filename, subject):
"""ํ
์คํธ ์์ฝํ๊ธฐ"""
# ํ๋กฌํํธ ์์ฑ (์ด๊ฒ ์ ๋ง ์ค์ํด์!)
prompt = f"""
๋น์ ์ ์ ๋ฌธ ๋น์ฆ๋์ค ๋ฌธ์ ๋ถ์๊ฐ์
๋๋ค.
๋ค์ ๋ฌธ์๋ฅผ ๋ถ์ํ๊ณ ํต์ฌ ๋ด์ฉ์ ์์ฝํด์ฃผ์ธ์.
๋ฌธ์ ์ ๋ณด:
- ํ์ผ๋ช
: {filename}
- ์ด๋ฉ์ผ ์ ๋ชฉ: {subject}
๋ฌธ์ ๋ด์ฉ:
{text[:100000]} # ํ ํฐ ์ ํ์ ๊ณ ๋ คํด 10๋ง ๊ธ์๊น์ง๋ง
๋ค์ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
## ๐ ๋ฌธ์ ๊ฐ์
- ๋ฌธ์ ์ ํ:
- ์ฃผ์ ๋ชฉ์ :
## ๐ฏ ํต์ฌ ๋ด์ฉ (3-5๊ฐ bullet points)
-
-
-
## ๐ ์ฃผ์ ๋ฐ์ดํฐ/์์น (์๋ ๊ฒฝ์ฐ)
-
-
## โ ๏ธ ์ฃผ์์ฌํญ ๋๋ ์ก์
์์ดํ
-
-
## ๐ก ์ข
ํฉ ์๊ฒฌ
(2-3๋ฌธ์ฅ์ผ๋ก ์ ์ฒด ๋ด์ฉ์ ์์ฝ)
์์ฝ์ ๋ช
ํํ๊ณ ๊ฐ๊ฒฐํ๊ฒ, ๋น์ฆ๋์ค ์์ฌ๊ฒฐ์ ์ ๋์์ด ๋๋๋ก ์์ฑํด์ฃผ์ธ์.
"""
try:
print(f"๐ค Claude์๊ฒ ์์ฝ ์์ฒญ ์ค...")
# API ํธ์ถ
message = self.client.messages.create(
model=self.model,
max_tokens=2000,
temperature=0.3, # ๋ฎ์์๋ก ์ผ๊ด์ฑ ์๊ณ ์ ํํ ๋ต๋ณ
messages=[
{"role": "user", "content": prompt}
]
)
summary = message.content[0].text
print(f"โ
์์ฝ ์๋ฃ! (ํ ํฐ ์ฌ์ฉ: {message.usage.input_tokens} in, {message.usage.output_tokens} out)")
return {
'summary': summary,
'filename': filename,
'subject': subject,
'tokens_used': {
'input': message.usage.input_tokens,
'output': message.usage.output_tokens
}
}
except Exception as e:
print(f"โ ์์ฝ ์คํจ: {e}")
return None
def batch_summarize(self, file_texts):
"""์ฌ๋ฌ ํ์ผ ์ผ๊ด ์์ฝ"""
results = []
for file_info in file_texts:
result = self.summarize(
file_info['text'],
file_info['filename'],
file_info['subject']
)
if result:
results.append(result)
return results
ํ๋กฌํํธ๋ฅผ ๋ณด๋ฉด ๊ตฌ์กฐํ๋ ํ์์ผ๋ก ์์ฝ์ ์์ฒญํ๊ณ ์์ฃ ? ์ด๋ ๊ฒ ํ๋ฉด ๊ฒฐ๊ณผ๋ฌผ์ด ์ผ๊ด์ฑ ์๊ฒ ๋์์ ๋์ค์ ์ฒ๋ฆฌํ๊ธฐ ํจ์ฌ ์ฌ์์! ๐
temperature ๊ฐ์ 0.3์ผ๋ก ๋ฎ๊ฒ ์ค์ ํ์ด์. ์ด๋ ๊ฒ ํ๋ฉด ์ฐฝ์์ ์ด๊ธฐ๋ณด๋ค๋ ์ ํํ๊ณ ์ผ๊ด๋ ๋ต๋ณ์ ์ป์ ์ ์๊ฑฐ๋ ์. ๋น์ฆ๋์ค ๋ฌธ์ ์์ฝ์๋ ์ ํ์ฑ์ด ์ต์ฐ์ ์ด๋๊น์! ๐ฏ
2. ๊ตฌ์กฐํ: ์ํ๋ ์ถ๋ ฅ ํ์์ ๋ช ํํ๊ฒ ์ ์ํ์ธ์. ๋งํฌ๋ค์ด, JSON, ํ ๋ฑ ํ์์ ์ง์ ํ๋ฉด ๊ทธ๋๋ก ๋ฐ๋ผ์์.
3. ์์ ์ ๊ณต: Few-shot learning ๊ธฐ๋ฒ์ผ๋ก ์์๋ฅผ ๋ช ๊ฐ ๋ณด์ฌ์ฃผ๋ฉด ๋ ์ ํํ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด์.
4. ์ ์ฝ ์กฐ๊ฑด: "3-5๊ฐ์ bullet points", "2-3๋ฌธ์ฅ์ผ๋ก" ๊ฐ์ ๊ตฌ์ฒด์ ์ธ ์ ์ฝ์ ์ฃผ๋ฉด ์ํ๋ ๊ธธ์ด๋ก ์์ฝ๋ผ์.
5๏ธโฃ ๊ฒฐ๊ณผ ์ ์ฅ ๋ฐ ์๋ฆผ
์์ฝ๋ ๋ด์ฉ์ ์ ์ฅํ๊ณ ์ฌ์ฉ์์๊ฒ ์๋ฆผ์ ๋ณด๋ด๋ ๋ถ๋ถ์ด์์. ์ฌ๋ฌ ๋ฐฉ๋ฒ์ด ์์ง๋ง, ์ฌ๊ธฐ์๋ ๊ฐ๋จํ๊ฒ JSON ํ์ผ๋ก ์ ์ฅํ๊ณ ์ด๋ฉ์ผ๋ก ์๋ฆผ์ ๋ณด๋ด๋ณผ๊ฒ์! ๐ฌ
import json
from datetime import datetime
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
class ResultManager:
def __init__(self, output_folder='summaries'):
self.output_folder = output_folder
if not os.path.exists(output_folder):
os.makedirs(output_folder)
def save_summary(self, summary_data):
"""์์ฝ ๊ฒฐ๊ณผ๋ฅผ JSON ํ์ผ๋ก ์ ์ฅ"""
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
filename = f"summary_{timestamp}.json"
filepath = os.path.join(self.output_folder, filename)
# ๋ฉํ๋ฐ์ดํฐ ์ถ๊ฐ
summary_data['timestamp'] = timestamp
summary_data['processed_at'] = datetime.now().isoformat()
with open(filepath, 'w', encoding='utf-8') as f:
json.dump(summary_data, f, ensure_ascii=False, indent=2)
print(f"๐พ ์์ฝ ์ ์ฅ ์๋ฃ: {filepath}")
return filepath
def send_notification_email(self, summaries, recipient_email):
"""์์ฝ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ฉ์ผ๋ก ์ ์ก"""
sender_email = os.getenv('EMAIL_ADDRESS')
sender_password = os.getenv('EMAIL_PASSWORD')
# ์ด๋ฉ์ผ ๋ด์ฉ ์์ฑ
html_content = self._create_email_html(summaries)
msg = MIMEMultipart('alternative')
msg['Subject'] = f"๐ ๋ฌธ์ ์์ฝ ์๋ฃ - {len(summaries)}๊ฐ ํ์ผ"
msg['From'] = sender_email
msg['To'] = recipient_email
html_part = MIMEText(html_content, 'html')
msg.attach(html_part)
try:
# Gmail SMTP ์๋ฒ๋ก ์ ์ก
with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
server.login(sender_email, sender_password)
server.send_message(msg)
print(f"๐ง ์๋ฆผ ์ด๋ฉ์ผ ์ ์ก ์๋ฃ: {recipient_email}")
return True
except Exception as e:
print(f"โ ์ด๋ฉ์ผ ์ ์ก ์คํจ: {e}")
return False
def _create_email_html(self, summaries):
"""์ด๋ฉ์ผ HTML ์์ฑ"""
html = """
<html>
<head>
<style>
body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }
.container { max-width: 800px; margin: 0 auto; padding: 20px; }
.header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white; padding: 30px; border-radius: 10px; text-align: center; }
.summary-box { background: #f8f9fa; border-left: 4px solid #667eea;
padding: 20px; margin: 20px 0; border-radius: 5px; }
.filename { color: #667eea; font-weight: bold; font-size: 1.2em; }
.content { margin-top: 10px; white-space: pre-wrap; }
.footer { text-align: center; color: #666; margin-top: 40px; padding-top: 20px;
border-top: 1px solid #ddd; }
</style>
</head>
<body>
<div class="container">
<div class="header">
<h1>๐ ๋ฌธ์ ์์ฝ ์๋ฃ!</h1>
<p>์ด """ + str(len(summaries)) + """๊ฐ์ ๋ฌธ์๊ฐ ์ฒ๋ฆฌ๋์์ต๋๋ค.</p>
</div>
"""
for idx, summary in enumerate(summaries, 1):
html += f"""
<div class="summary-box">
<div class="filename">๐ {idx}. {summary['filename']}</div>
<div style="color: #666; font-size: 0.9em; margin-top: 5px;">
์ด๋ฉ์ผ ์ ๋ชฉ: {summary['subject']}
</div>
<div class="content">{summary['summary']}</div>
<div style="color: #999; font-size: 0.85em; margin-top: 10px;">
ํ ํฐ ์ฌ์ฉ: {summary['tokens_used']['input']} in / {summary['tokens_used']['output']} out
</div>
</div>
"""
html += """
<div class="footer">
<p>๐ค Powered by Claude API</p>
<p>์ด ์์ฝ์ AI๊ฐ ์๋์ผ๋ก ์์ฑํ ๊ฒ์
๋๋ค. ์ค์ํ ์์ฌ๊ฒฐ์ ์ ์๋ ์๋ณธ ๋ฌธ์๋ฅผ ํ์ธํด์ฃผ์ธ์.</p>
</div>
</div>
</body>
</html>
"""
return html
์ด๋ฉ์ผ ์๋ฆผ์ HTML ํ์์ผ๋ก ์์๊ฒ ๊พธ๋ฉฐ์ ๋ณด๋ด๋ฉด ๊ฐ๋
์ฑ์ด ํจ์ฌ ์ข์์! ๐ง
์ค๋ฌด์์๋ ์ฌ๋(Slack) ์นํ
์ ์ฌ์ฉํ๊ฑฐ๋, ํ
๋ ๊ทธ๋จ ๋ด, ์นด์นด์คํก ์๋ฆผํก ๋ฑ ๋ค์ํ ์ฑ๋์ ํ์ฉํ ์ ์์ด์. ํ์ฌ ์ํฉ์ ๋ง๊ฒ ์ ํํ๋ฉด ๋์ฃ ! ๐ฌ
๐ ์ ์ฒด ์์คํ ํตํฉํ๊ธฐ
์ด์ ์ง๊ธ๊น์ง ๋ง๋ ๋ชจ๋ ์ปดํฌ๋ํธ๋ฅผ ํ๋๋ก ํฉ์ณ์ ์์ ํ ์์คํ ์ ๋ง๋ค์ด๋ณผ๊ฒ์! ๐
import schedule
import time
from datetime import datetime
class EmailSummarizerSystem:
def __init__(self):
self.email_fetcher = EmailFetcher()
self.file_parser = FileParser()
self.summarizer = ClaudeSummarizer()
self.result_manager = ResultManager()
# ์๋ฆผ ๋ฐ์ ์ด๋ฉ์ผ ์ฃผ์
self.notification_email = os.getenv('NOTIFICATION_EMAIL',
os.getenv('EMAIL_ADDRESS'))
def process_emails(self):
"""์ด๋ฉ์ผ ์ฒ๋ฆฌ ๋ฉ์ธ ๋ก์ง"""
print(f"\n{'='*50}")
print(f"๐ ์ด๋ฉ์ผ ์ฒ๋ฆฌ ์์: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"{'='*50}\n")
# 1. ์ด๋ฉ์ผ ์๋ฒ ์ฐ๊ฒฐ
if not self.email_fetcher.connect():
print("โ ์ด๋ฉ์ผ ์๋ฒ ์ฐ๊ฒฐ ์คํจ. ๋ค์ ์ค์ผ์ค์ ์ฌ์๋ํฉ๋๋ค.")
return
try:
# 2. ์ ์ด๋ฉ์ผ ํ์ธ
email_ids = self.email_fetcher.fetch_unread_emails()
if not email_ids:
print("๐ญ ์๋ก์ด ์ด๋ฉ์ผ์ด ์์ต๋๋ค.")
return
all_summaries = []
# 3. ๊ฐ ์ด๋ฉ์ผ ์ฒ๋ฆฌ
for email_id in email_ids:
# ์ฒจ๋ถํ์ผ ๋ค์ด๋ก๋
attachments = self.email_fetcher.download_attachments(email_id)
if not attachments:
print("โ ๏ธ ์ฒจ๋ถํ์ผ์ด ์๋ ์ด๋ฉ์ผ์
๋๋ค.")
continue
# 4. ํ
์คํธ ์ถ์ถ
file_texts = []
for attachment in attachments:
text = self.file_parser.parse_file(attachment['filepath'])
if text:
file_texts.append({
'text': text,
'filename': attachment['filename'],
'subject': attachment['subject']
})
# 5. Claude๋ก ์์ฝ
if file_texts:
summaries = self.summarizer.batch_summarize(file_texts)
all_summaries.extend(summaries)
# 6. ๊ฒฐ๊ณผ ์ ์ฅ
for summary in summaries:
self.result_manager.save_summary(summary)
# 7. ์๋ฆผ ์ ์ก
if all_summaries:
self.result_manager.send_notification_email(
all_summaries,
self.notification_email
)
print(f"\nโ
์ด {len(all_summaries)}๊ฐ ๋ฌธ์ ์ฒ๋ฆฌ ์๋ฃ!")
else:
print("\nโ ๏ธ ์ฒ๋ฆฌํ ์ ์๋ ์ฒจ๋ถํ์ผ์ด ์์์ต๋๋ค.")
finally:
# 8. ์ฐ๊ฒฐ ์ข
๋ฃ
self.email_fetcher.disconnect()
print(f"\n{'='*50}")
print(f"โจ ์ฒ๋ฆฌ ์๋ฃ: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"{'='*50}\n")
def start_scheduler(self, interval_minutes=10):
"""์ค์ผ์ค๋ฌ ์์"""
print(f"โฐ ์ค์ผ์ค๋ฌ ์์: {interval_minutes}๋ถ๋ง๋ค ์ด๋ฉ์ผ ํ์ธ")
# ์ฆ์ ํ ๋ฒ ์คํ
self.process_emails()
# ์ฃผ๊ธฐ์ ์คํ ์ค์ผ์ค ๋ฑ๋ก
schedule.every(interval_minutes).minutes.do(self.process_emails)
# ๋ฌดํ ๋ฃจํ๋ก ์ค์ผ์ค ์คํ
while True:
schedule.run_pending()
time.sleep(60) # 1๋ถ๋ง๋ค ์ค์ผ์ค ์ฒดํฌ
# ๋ฉ์ธ ์คํ ์ฝ๋
if __name__ == "__main__":
print("""
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ โ
โ ๐ง Claude API ์ด๋ฉ์ผ ์ฒจ๋ถํ์ผ ์๋์์ฝ ์์คํ
โ
โ โ
โ Powered by Claude AI ๐ค โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
""")
# ์์คํ
์ด๊ธฐํ ๋ฐ ์์
system = EmailSummarizerSystem()
try:
# 10๋ถ๋ง๋ค ์ด๋ฉ์ผ ํ์ธ
system.start_scheduler(interval_minutes=10)
except KeyboardInterrupt:
print("\n\n๐ ์์คํ
์ ์ข
๋ฃํฉ๋๋ค. ์๋
ํ ๊ฐ์ธ์!")
except Exception as e:
print(f"\nโ ์ค๋ฅ ๋ฐ์: {e}")
print("์์คํ
์ ์ฌ์์ํด์ฃผ์ธ์.")
์ด์ ์์ฑ์ด์์! ๐ ์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด 10๋ถ๋ง๋ค ์๋์ผ๋ก ์ด๋ฉ์ผ์ ํ์ธํ๊ณ , ์๋ก์ด ์ฒจ๋ถํ์ผ์ด ์์ผ๋ฉด ๋ค์ด๋ก๋ํด์ ์์ฝํ ๋ค์, ๊ฒฐ๊ณผ๋ฅผ ์ด๋ฉ์ผ๋ก ๋ณด๋ด์ค์.
ํฐ๋ฏธ๋์์ python main.py ๋ช
๋ น์ด๋ก ์คํํ๋ฉด ๋๊ณ , ๋ฐฑ๊ทธ๋ผ์ด๋์์ ๊ณ์ ๋๋ฆฌ๊ณ ์ถ๋ค๋ฉด nohup์ด๋ systemd ์๋น์ค๋ก ๋ฑ๋กํ๋ฉด ๋ผ์! ๐
2. ๋ก๊ทธ๋ฅผ ํ์ผ๋ก ์ ์ฅํ๊ณ ์ถ๋ค๋ฉด logging ๋ชจ๋์ ์ถ๊ฐํ์ธ์.
3. ์๋ฌ๊ฐ ๋ฐ์ํด๋ ์์คํ ์ด ๋ฉ์ถ์ง ์๋๋ก try-except๋ฅผ ์ถฉ๋ถํ ํ์ฉํ์ธ์.
4. ์๋ฒ์์ 24์๊ฐ ๋๋ฆด ๊ฑฐ๋ผ๋ฉด Docker ์ปจํ ์ด๋๋ก ๋ง๋๋ ๊ฑธ ์ถ์ฒํด์!
โก ์ฑ๋ฅ ์ต์ ํ ๋ฐ ๊ณ ๊ธ ๊ธฐ๋ฅ
๊ธฐ๋ณธ ์์คํ ์ ์์ฑํ์ง๋ง, ์ค์ ์ ๋ฌด์ ์ฌ์ฉํ๋ ค๋ฉด ๋ช ๊ฐ์ง ์ต์ ํ์ ๊ณ ๊ธ ๊ธฐ๋ฅ์ด ํ์ํด์. ํ๋์ฉ ์ดํด๋ณผ๊น์? ๐ง
1๏ธโฃ ๋น์ฉ ์ต์ ํ ์ ๋ต
๐ฏ ๋ชจ๋ธ ์ ํ ์ ๋ต
Claude๋ ์ฌ๋ฌ ๋ชจ๋ธ์ ์ ๊ณตํ๋๋ฐ, ์ฉ๋์ ๋ง๊ฒ ์ ํํ๋ฉด ๋น์ฉ์ ํฌ๊ฒ ์ ๊ฐํ ์ ์์ด์!
| ๋ชจ๋ธ | ํน์ง | ๊ฐ๊ฒฉ (100๋ง ํ ํฐ) | ์ถ์ฒ ์ฉ๋ |
|---|---|---|---|
| Claude 3 Haiku | ๋น ๋ฅด๊ณ ์ ๋ ด | $0.25 / $1.25 | ์ผ๋ฐ ๋ฌธ์ ์์ฝ |
| Claude 3 Sonnet | ๊ท ํ์กํ ์ฑ๋ฅ | $3 / $15 | ๋ณต์กํ ๋ถ์ |
| Claude 3 Opus | ์ต๊ณ ์ฑ๋ฅ | $15 / $75 | ์ ๋ฌธ ๋ถ์ผ ๋ฌธ์ |
์ผ๋ฐ์ ์ธ ๋น์ฆ๋์ค ๋ฌธ์๋ Haiku๋ก ์ถฉ๋ถํด์. ๋ฒ๋ฅ ๋ฌธ์๋ ์๋ฃ ๋ฌธ์์ฒ๋ผ ์ ํ๋๊ฐ ๋งค์ฐ ์ค์ํ ๊ฒฝ์ฐ์๋ง Opus๋ฅผ ์ฌ์ฉํ์ธ์! ๐ฐ
# ๋ฌธ์ ์ ํ์ ๋ฐ๋ผ ๋ชจ๋ธ ์๋ ์ ํ
class SmartSummarizer(ClaudeSummarizer):
def select_model(self, filename, text_length):
"""๋ฌธ์ ํน์ฑ์ ๋ฐ๋ผ ์ต์ ๋ชจ๋ธ ์ ํ"""
# ํ์ผ๋ช
์ด๋ ๋ด์ฉ์ผ๋ก ๋ฌธ์ ์ ํ ํ๋จ
if any(keyword in filename.lower() for keyword in ['๊ณ์ฝ', 'contract', '๋ฒ๋ฅ ', 'legal']):
return "claude-3-sonnet-20240229" # ์ค์ ๋ฌธ์๋ Sonnet
# ํ
์คํธ๊ฐ ๋งค์ฐ ๊ธธ๋ฉด Haiku๋ก (๋น์ฉ ์ ๊ฐ)
if text_length > 50000:
return "claude-3-haiku-20240307"
# ๊ธฐ๋ณธ์ Haiku
return "claude-3-haiku-20240307"
def summarize_smart(self, text, filename, subject):
"""์ค๋งํธ ์์ฝ (๋ชจ๋ธ ์๋ ์ ํ)"""
self.model = self.select_model(filename, len(text))
print(f"๐ค ์ ํ๋ ๋ชจ๋ธ: {self.model}")
return self.summarize(text, filename, subject)
2๏ธโฃ ์บ์ฑ์ผ๋ก ์๋ ํฅ์
๊ฐ์ ๋ฌธ์๋ฅผ ์ฌ๋ฌ ๋ฒ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ๊ฐ ์์ ์ ์์ด์. ์ด๋ด ๋๋ ์บ์ฑ์ ํ์ฉํ๋ฉด API ํธ์ถ์ ์ค์ผ ์ ์์ฃ ! โก
import hashlib
import json
import os
class CachedSummarizer(ClaudeSummarizer):
def __init__(self, cache_folder='cache'):
super().__init__()
self.cache_folder = cache_folder
if not os.path.exists(cache_folder):
os.makedirs(cache_folder)
def get_cache_key(self, text):
"""ํ
์คํธ์ ํด์๊ฐ์ผ๋ก ์บ์ ํค ์์ฑ"""
return hashlib.md5(text.encode()).hexdigest()
def get_cached_summary(self, cache_key):
"""์บ์์์ ์์ฝ ๊ฐ์ ธ์ค๊ธฐ"""
cache_file = os.path.join(self.cache_folder, f"{cache_key}.json")
if os.path.exists(cache_file):
with open(cache_file, 'r', encoding='utf-8') as f:
cached_data = json.load(f)
print("๐พ ์บ์์์ ์์ฝ ๋ก๋!")
return cached_data
return None
def save_to_cache(self, cache_key, summary_data):
"""์์ฝ ๊ฒฐ๊ณผ๋ฅผ ์บ์์ ์ ์ฅ"""
cache_file = os.path.join(self.cache_folder, f"{cache_key}.json")
with open(cache_file, 'w', encoding='utf-8') as f:
json.dump(summary_data, f, ensure_ascii=False, indent=2)
def summarize_with_cache(self, text, filename, subject):
"""์บ์ฑ์ ํ์ฉํ ์์ฝ"""
cache_key = self.get_cache_key(text)
# ์บ์ ํ์ธ
cached = self.get_cached_summary(cache_key)
if cached:
return cached
# ์บ์ ์์ผ๋ฉด ์๋ก ์์ฝ
result = self.summarize(text, filename, subject)
if result:
self.save_to_cache(cache_key, result)
return result
์ด๋ ๊ฒ ํ๋ฉด ๊ฐ์ ๋ฌธ์๊ฐ ๋ค์ ๋ค์ด์๋ API๋ฅผ ํธ์ถํ์ง ์๊ณ ์บ์์์ ๋ฐ๋ก ๊ฐ์ ธ์์. ์๋๋ ๋น ๋ฅด๊ณ ๋น์ฉ๋ ์ ๊ฐ๋์ฃ ! ๐ฏ
3๏ธโฃ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ก ์๋ ๊ฐ์
์ฌ๋ฌ ๊ฐ์ ํ์ผ์ ์ฒ๋ฆฌํ ๋ ์์ฐจ์ ์ผ๋ก ํ๋์ฉ ์ฒ๋ฆฌํ๋ฉด ์๊ฐ์ด ์ค๋ ๊ฑธ๋ ค์. ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ํ์ฉํ๋ฉด ํจ์ฌ ๋นจ๋ผ์ ธ์! ๐
from concurrent.futures import ThreadPoolExecutor, as_completed
class ParallelSummarizer(ClaudeSummarizer):
def batch_summarize_parallel(self, file_texts, max_workers=3):
"""๋ณ๋ ฌ๋ก ์ฌ๋ฌ ํ์ผ ์์ฝ"""
results = []
with ThreadPoolExecutor(max_workers=max_workers) as executor:
# ๋ชจ๋ ์์
์ ์ ์ถ
future_to_file = {
executor.submit(
self.summarize,
file_info['text'],
file_info['filename'],
file_info['subject']
): file_info for file_info in file_texts
}
# ์๋ฃ๋๋ ๋๋ก ๊ฒฐ๊ณผ ์์ง
for future in as_completed(future_to_file):
file_info = future_to_file[future]
try:
result = future.result()
if result:
results.append(result)
print(f"โ
{file_info['filename']} ์ฒ๋ฆฌ ์๋ฃ")
except Exception as e:
print(f"โ {file_info['filename']} ์ฒ๋ฆฌ ์คํจ: {e}")
return results
max_workers=3์ผ๋ก ์ค์ ํ๋ฉด ์ต๋ 3๊ฐ์ ํ์ผ์ ๋์์ ์ฒ๋ฆฌํด์. ๋๋ฌด ๋ง์ด ๋๋ฆฌ๋ฉด API rate limit์ ๊ฑธ๋ฆด ์ ์์ผ๋ ์ฃผ์ํ์ธ์! โ ๏ธ
4๏ธโฃ ์๋ฌ ์ฒ๋ฆฌ ๋ฐ ์ฌ์๋ ๋ก์ง
๋คํธ์ํฌ ๋ฌธ์ ๋ API ์ค๋ฅ๋ก ์คํจํ ์ ์์ด์. ์๋์ผ๋ก ์ฌ์๋ํ๋ ๋ก์ง์ ์ถ๊ฐํ๋ฉด ์์ ์ฑ์ด ๋์์ ธ์! ๐ก๏ธ
import time
from functools import wraps
def retry_on_failure(max_retries=3, delay=2):
"""์คํจ์ ์ฌ์๋ํ๋ ๋ฐ์ฝ๋ ์ดํฐ"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(max_retries):
try:
return func(*args, **kwargs)
except Exception as e:
if attempt == max_retries - 1:
print(f"โ {max_retries}๋ฒ ์๋ ํ ์คํจ: {e}")
raise
wait_time = delay * (2 ** attempt) # ์ง์ ๋ฐฑ์คํ
print(f"โ ๏ธ ์ค๋ฅ ๋ฐ์, {wait_time}์ด ํ ์ฌ์๋... (์๋ {attempt + 1}/{max_retries})")
time.sleep(wait_time)
return wrapper
return decorator
class RobustSummarizer(ClaudeSummarizer):
@retry_on_failure(max_retries=3, delay=2)
def summarize_robust(self, text, filename, subject):
"""์ฌ์๋ ๋ก์ง์ด ํฌํจ๋ ์์ฝ"""
return self.summarize(text, filename, subject)
์ง์ ๋ฐฑ์คํ(Exponential Backoff) ์ ๋ต์ ์ฌ์ฉํด์ ์ฌ์๋ ๊ฐ๊ฒฉ์ ์ ์ ๋๋ ค์. ์ฒซ ๋ฒ์งธ๋ 2์ด, ๋ ๋ฒ์งธ๋ 4์ด, ์ธ ๋ฒ์งธ๋ 8์ด ์ด๋ฐ ์์ผ๋ก์. ์ด๋ ๊ฒ ํ๋ฉด ์ผ์์ ์ธ ๋คํธ์ํฌ ๋ฌธ์ ๋ฅผ ์ ๊ทน๋ณตํ ์ ์์ด์! ๐ช
๐ ์ค์ ํ์ฉ ์ฌ๋ก
์ด๋ก ์ ์ถฉ๋ถํ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉ๋๋์ง ์ฌ๋ก๋ฅผ ์ดํด๋ณผ๊น์? ๐
๐ข ์ฌ๋ก 1: ๋ฒ๋ฅ ์ฌ๋ฌด์ ๊ณ์ฝ์ ๊ฒํ
์ํฉ: ํ ๋ฒ๋ฅ ์ฌ๋ฌด์์์๋ ๋งค์ผ ์์ญ ๊ฑด์ ๊ณ์ฝ์๋ฅผ ์ด๋ฉ์ผ๋ก ๋ฐ์์. ๋ณํธ์ฌ๋ค์ด ์ผ์ผ์ด ์ฝ๊ณ ๊ฒํ ํ๋ ๋ฐ ํ๋ฃจ 3-4์๊ฐ์ด ์์๋์ฃ .
์๋ฃจ์ : Claude API ์๋์์ฝ ์์คํ ์ ๋์ ํด์ ๊ณ์ฝ์์ ํต์ฌ ์กฐํญ, ์ฃผ์์ฌํญ, ๋ฆฌ์คํฌ ์์๋ฅผ ์๋์ผ๋ก ์ถ์ถํ์ด์.
๊ฒฐ๊ณผ:
โ
๊ฒํ ์๊ฐ 70% ๋จ์ถ (4์๊ฐ โ 1.2์๊ฐ)
โ
์ค์ ์กฐํญ ๋๋ฝ ์ฌ๋ก 90% ๊ฐ์
โ
๋ณํธ์ฌ๋ค์ด ์ค์ ๋ฒ๋ฅ ์๋ฌธ์ ๋ ๋ง์ ์๊ฐ ํฌ์ ๊ฐ๋ฅ
๐ฐ ์ ๋น์ฉ: ์ฝ $15 (Claude API ์ฌ์ฉ๋ฃ)
๐ผ ์ฌ๋ก 2: ์ปจ์คํ ํ์ฌ ๋ณด๊ณ ์ ๋ถ์
์ํฉ: ๊ฒฝ์ ์ปจ์คํ ํ์ฌ์์ ํด๋ผ์ด์ธํธ๋ค๋ก๋ถํฐ ๋ฐ๋ ์ฌ๋ฌด์ ํ, ์ฌ์ ๊ณํ์, ์์ฅ์กฐ์ฌ ๋ณด๊ณ ์ ๋ฑ์ ๋ถ์ํด์ผ ํ์ด์.
์๋ฃจ์ : ๋ฌธ์ ์ ํ๋ณ๋ก ๋ง์ถคํ ํ๋กฌํํธ๋ฅผ ์์ฑํด์ ์ฌ๋ฌด ์งํ, ์์ฅ ํธ๋ ๋, ๋ฆฌ์คํฌ ์์ธ ๋ฑ์ ์๋์ผ๋ก ์ถ์ถํ๋๋ก ํ์ด์.
๊ฒฐ๊ณผ:
โ
์ด๊ธฐ ๋ถ์ ์๊ฐ 60% ๋จ์ถ
โ
๋ฐ์ดํฐ ๊ธฐ๋ฐ ์ธ์ฌ์ดํธ ๋์ถ ์๋ ํฅ์
โ
์ปจ์คํดํธ 1๋ช
๋น ์ฒ๋ฆฌ ๊ฐ๋ฅํ ํ๋ก์ ํธ ์ 50% ์ฆ๊ฐ
๐ฐ ์ ๋น์ฉ: ์ฝ $30
๐ฅ ์ฌ๋ก 3: ๋ณ์ ์๋ฃ ๊ธฐ๋ก ์์ฝ
์ํฉ: ๋ํ ๋ณ์์์ ํ์ ์ ์ ์ ๋ค๋ฅธ ๋ณ์์์ ๋ณด๋ธ ์๋ฃ ๊ธฐ๋ก์ ๊ฒํ ํด์ผ ํ์ด์. ๊ธฐ๋ก์ด ์์ญ ํ์ด์ง์ ๋ฌํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์ฃ .
์๋ฃจ์ : ์๋ฃ ์ฉ์ด์ ํนํ๋ ํ๋กฌํํธ๋ก ์ฃผ์ ์ง๋จ๋ช , ์ฒ๋ฐฉ ๋ด์ญ, ์๋ ๋ฅด๊ธฐ ์ ๋ณด, ์ฃผ์์ฌํญ์ ์๋ ์ถ์ถํ์ด์.
๊ฒฐ๊ณผ:
โ
์๋ฃ์ง์ ๊ธฐ๋ก ๊ฒํ ์๊ฐ 80% ๋จ์ถ
โ
์ค์ ์ ๋ณด ๋๋ฝ์ผ๋ก ์ธํ ์๋ฃ ์ฌ๊ณ ์ํ ๊ฐ์
โ
ํ์ ๋๊ธฐ ์๊ฐ ๋จ์ถ์ผ๋ก ๋ง์กฑ๋ ํฅ์
๐ฐ ์ ๋น์ฉ: ์ฝ $50
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ AI ์๋ํ ์๋ฃจ์ ์ ๊ตฌ์ถํด์ฃผ๋ ์ฌ๋ฅ์ด ์ธ๊ธฐ๊ฐ ๋ง์์. ํนํ ํน์ ์ฐ์ ์ ํนํ๋ ์ปค์คํฐ๋ง์ด์ง ์๋น์ค๋ ๋์ ๊ฐ๊ฒฉ์ ๊ฑฐ๋๋๊ณ ์์ฃ ! ๐ผ
๐ ๋ณด์ ๋ฐ ๊ฐ์ธ์ ๋ณด ๋ณดํธ
๋น์ฆ๋์ค ๋ฌธ์๋ฅผ ๋ค๋ฃจ๋ค ๋ณด๋ฉด ๋ฏผ๊ฐํ ์ ๋ณด๊ฐ ๋ง์ด ํฌํจ๋์ด ์์ด์. ๋ณด์์ ์ ๋ง ์ค์ํ ๋ถ๋ถ์ด์ฃ ! ๐
๐ก๏ธ ํ์ ๋ณด์ ์กฐ์น
1. API ํค ๊ด๋ฆฌ
- ํ๊ฒฝ ๋ณ์๋ .env ํ์ผ ์ฌ์ฉ (์ ๋ ์ฝ๋์ ์ง์ ์
๋ ฅ ๊ธ์ง!)
- AWS Secrets Manager, Azure Key Vault ๊ฐ์ ์ ๋ฌธ ์๋น์ค ํ์ฉ
- ์ ๊ธฐ์ ์ผ๋ก API ํค ๊ต์ฒด (3๊ฐ์๋ง๋ค ๊ถ์ฅ)
2. ๋ฐ์ดํฐ ์ํธํ
- ์ ์ฅ๋๋ ์์ฝ ํ์ผ ์ํธํ (AES-256 ๊ถ์ฅ)
- ์ ์ก ์ค ๋ฐ์ดํฐ๋ HTTPS/TLS ์ฌ์ฉ
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฌ์ฉ ์ ์ํธํ ํ๋ ํ์ฉ
3. ์ ๊ทผ ์ ์ด
- ์์คํ
์ ๊ทผ ๊ถํ์ ์ต์ํ์ผ๋ก ์ ํ
- ๋ก๊ทธ์ธ ์ธ์ฆ ์ถ๊ฐ (OAuth, JWT ๋ฑ)
- IP ํ์ดํธ๋ฆฌ์คํธ ์ค์
4. ๋ฐ์ดํฐ ๋ณด๊ด ์ ์ฑ
- ์์ฝ ํ์ผ ์๋ ์ญ์ ์ ์ฑ
(์: 30์ผ ํ ์ญ์ )
- ์๋ณธ ์ฒจ๋ถํ์ผ์ ์ฒ๋ฆฌ ํ ์ฆ์ ์ญ์
- ๋ก๊ทธ ํ์ผ๋ ์ฃผ๊ธฐ์ ์ผ๋ก ์ ๋ฆฌ
# ํ์ผ ์ํธํ ์์
from cryptography.fernet import Fernet
import os
class SecureStorage:
def __init__(self):
# ์ํธํ ํค ์์ฑ ๋๋ ๋ก๋
key_file = 'encryption.key'
if os.path.exists(key_file):
with open(key_file, 'rb') as f:
self.key = f.read()
else:
self.key = Fernet.generate_key()
with open(key_file, 'wb') as f:
f.write(self.key)
self.cipher = Fernet(self.key)
def encrypt_file(self, filepath):
"""ํ์ผ ์ํธํ"""
with open(filepath, 'rb') as f:
data = f.read()
encrypted_data = self.cipher.encrypt(data)
encrypted_filepath = filepath + '.encrypted'
with open(encrypted_filepath, 'wb') as f:
f.write(encrypted_data)
# ์๋ณธ ํ์ผ ์ญ์
os.remove(filepath)
return encrypted_filepath
def decrypt_file(self, encrypted_filepath):
"""ํ์ผ ๋ณตํธํ"""
with open(encrypted_filepath, 'rb') as f:
encrypted_data = f.read()
decrypted_data = self.cipher.decrypt(encrypted_data)
original_filepath = encrypted_filepath.replace('.encrypted', '')
with open(original_filepath, 'wb') as f:
f.write(decrypted_data)
return original_filepath
def secure_delete(self, filepath):
"""์์ ํ ํ์ผ ์ญ์ (๋ฎ์ด์ฐ๊ธฐ ํ ์ญ์ )"""
if os.path.exists(filepath):
# ํ์ผ์ ๋๋ค ๋ฐ์ดํฐ๋ก ๋ฎ์ด์ฐ๊ธฐ
file_size = os.path.getsize(filepath)
with open(filepath, 'wb') as f:
f.write(os.urandom(file_size))
# ํ์ผ ์ญ์
os.remove(filepath)
print(f"๐๏ธ ์์ ํ๊ฒ ์ญ์ ๋จ: {filepath}")
๐ ๋ฐฐํฌ ๋ฐ ์ด์
๊ฐ๋ฐ์ ๋๋ฌ์ด์! ์ด์ ์ค์ ์๋ฒ์ ๋ฐฐํฌํด์ 24์๊ฐ ๋์๊ฐ๊ฒ ๋ง๋ค์ด๋ณผ๊น์? ๐
1๏ธโฃ Docker๋ก ์ปจํ ์ด๋ํ
Docker๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ค ํ๊ฒฝ์์๋ ๋์ผํ๊ฒ ์คํํ ์ ์์ด์. ๋ฐฐํฌ๊ฐ ์ ๋ง ์ฌ์์ง์ฃ ! ๐ณ
# Dockerfile
FROM python:3.9-slim
WORKDIR /app
# ์์คํ
ํจํค์ง ์ค์น
RUN apt-get update && apt-get install -y \
gcc \
&& rm -rf /var/lib/apt/lists/*
# Python ํจํค์ง ์ค์น
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# ์ ํ๋ฆฌ์ผ์ด์
์ฝ๋ ๋ณต์ฌ
COPY . .
# ํ๊ฒฝ ๋ณ์ ํ์ผ ๋ณต์ฌ (์ค์ ๋ก๋ Docker secrets ์ฌ์ฉ ๊ถ์ฅ)
COPY .env .
# ์คํ
CMD ["python", "main.py"]
# docker-compose.yml
version: '3.8'
services:
email-summarizer:
build: .
container_name: email_summarizer
restart: unless-stopped
volumes:
- ./attachments:/app/attachments
- ./summaries:/app/summaries
- ./cache:/app/cache
environment:
- TZ=Asia/Seoul
env_file:
- .env
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
์ด์ docker-compose up -d ๋ช ๋ น์ด ํ๋๋ก ์์คํ ์ ์คํํ ์ ์์ด์! ์ ๋ง ๊ฐํธํ์ฃ ? ๐
2๏ธโฃ ๋ชจ๋ํฐ๋ง ๋ฐ ๋ก๊น
์์คํ ์ด ์ ๋์๊ฐ๋์ง ๋ชจ๋ํฐ๋งํ๋ ๊ฒ๋ ์ค์ํด์. ๋ฌธ์ ๊ฐ ์๊ธฐ๋ฉด ๋ฐ๋ก ์ ์ ์์ด์ผ ํ๋๊น์! ๐
import logging
from logging.handlers import RotatingFileHandler
import sys
def setup_logging():
"""๋ก๊น
์ค์ """
# ๋ก๊ฑฐ ์์ฑ
logger = logging.getLogger('EmailSummarizer')
logger.setLevel(logging.INFO)
# ํฌ๋งท ์ค์
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
# ํ์ผ ํธ๋ค๋ฌ (10MB๋ง๋ค ๋กํ
์ด์
, ์ต๋ 5๊ฐ ํ์ผ ๋ณด๊ด)
file_handler = RotatingFileHandler(
'email_summarizer.log',
maxBytes=10*1024*1024,
backupCount=5,
encoding='utf-8'
)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO)
# ์ฝ์ ํธ๋ค๋ฌ
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setFormatter(formatter)
console_handler.setLevel(logging.INFO)
# ํธ๋ค๋ฌ ์ถ๊ฐ
logger.addHandler(file_handler)
logger.addHandler(console_handler)
return logger
# ์ฌ์ฉ ์์
logger = setup_logging()
logger.info("์์คํ
์์")
logger.warning("์ฃผ์: API ํธ์ถ ํ๋ 80% ๋๋ฌ")
logger.error("์ค๋ฅ ๋ฐ์: ์ด๋ฉ์ผ ์๋ฒ ์ฐ๊ฒฐ ์คํจ")
3๏ธโฃ ํฌ์ค ์ฒดํฌ ๋ฐ ์๋ฆผ
์์คํ ์ด ๋ฉ์ท์ ๋ ์๋์ผ๋ก ์๋ฆผ์ ๋ฐ์ ์ ์๊ฒ ํฌ์ค ์ฒดํฌ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณผ๊ฒ์! ๐ฅ
import requests
from datetime import datetime, timedelta
class HealthChecker:
def __init__(self):
self.last_success_time = datetime.now()
self.failure_count = 0
self.alert_threshold = 3 # 3๋ฒ ์ฐ์ ์คํจ์ ์๋ฆผ
def record_success(self):
"""์ฑ๊ณต ๊ธฐ๋ก"""
self.last_success_time = datetime.now()
self.failure_count = 0
def record_failure(self):
"""์คํจ ๊ธฐ๋ก"""
self.failure_count += 1
if self.failure_count >= self.alert_threshold:
self.send_alert()
def send_alert(self):
"""์ฌ๋์ผ๋ก ์๋ฆผ ์ ์ก"""
webhook_url = os.getenv('SLACK_WEBHOOK_URL')
if not webhook_url:
return
message = {
"text": "๐จ ์ด๋ฉ์ผ ์์ฝ ์์คํ
์ค๋ฅ ๋ฐ์!",
"attachments": [{
"color": "danger",
"fields": [
{
"title": "์ฐ์ ์คํจ ํ์",
"value": str(self.failure_count),
"short": True
},
{
"title": "๋ง์ง๋ง ์ฑ๊ณต ์๊ฐ",
"value": self.last_success_time.strftime('%Y-%m-%d %H:%M:%S'),
"short": True
}
]
}]
}
try:
response = requests.post(webhook_url, json=message)
if response.status_code == 200:
print("๐ข ์ฌ๋ ์๋ฆผ ์ ์ก ์๋ฃ")
except Exception as e:
print(f"โ ์ฌ๋ ์๋ฆผ ์ ์ก ์คํจ: {e}")
def check_health(self):
"""ํฌ์ค ์ฒดํฌ"""
time_since_success = datetime.now() - self.last_success_time
# 1์๊ฐ ์ด์ ์ฑ๊ณต ๊ธฐ๋ก์ด ์์ผ๋ฉด ๊ฒฝ๊ณ
if time_since_success > timedelta(hours=1):
print("โ ๏ธ ๊ฒฝ๊ณ : 1์๊ฐ ์ด์ ์ฒ๋ฆฌ ๊ธฐ๋ก ์์")
return False
return True
์ฌ๋ ์นํ ์ ์ค์ ํ๋ฉด ๋ฌธ์ ๊ฐ ์๊ฒผ์ ๋ ์ฆ์ ์๋ฆผ์ ๋ฐ์ ์ ์์ด์. ํด๋ํฐ์ผ๋ก๋ ์๋ฆผ์ด ์ค๋๊น ์ด๋์๋ ๋์ํ ์ ์์ฃ ! ๐ฑ
๐ก ํ๋กฌํํธ ์์ง๋์ด๋ง ์ฌํ
Claude์ ์ฑ๋ฅ์ ์ต๋๋ก ๋์ด๋ด๋ ค๋ฉด ํ๋กฌํํธ๋ฅผ ์ ์์ฑํ๋ ๊ฒ ์ ๋ง ์ค์ํด์. ๋ช ๊ฐ์ง ๊ณ ๊ธ ๊ธฐ๋ฒ์ ์๋ ค๋๋ฆด๊ฒ์! ๐จ
๐ฏ ์ฐ์ ๋ณ ๋ง์ถค ํ๋กฌํํธ
๋ฒ๋ฅ ๋ฌธ์์ฉ ํ๋กฌํํธ
๋น์ ์ 20๋
๊ฒฝ๋ ฅ์ ๋ณํธ์ฌ์
๋๋ค. ๋ค์ ๊ณ์ฝ์๋ฅผ ๋ถ์ํ๊ณ ์์ฝํด์ฃผ์ธ์.
ํนํ ๋ค์ ์ฌํญ์ ์ฃผ์ํด์ ๊ฒํ ํด์ฃผ์ธ์:
1. ๊ณ์ฝ ๋น์ฌ์ ๋ฐ ๊ณ์ฝ ๊ธฐ๊ฐ
2. ์ฃผ์ ๊ถ๋ฆฌ์ ์๋ฌด ์กฐํญ
3. ์ํด๋ฐฐ์ ๋ฐ ์์ฝ๊ธ ์กฐํญ
4. ๊ณ์ฝ ํด์ง ์กฐ๊ฑด
5. ๋ถ์ ํด๊ฒฐ ๋ฐฉ๋ฒ
6. ์ ์ฌ์ ๋ฒ์ ๋ฆฌ์คํฌ
[๋ฌธ์ ๋ด์ฉ]
{text}
๋ค์ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
## โ๏ธ ๊ณ์ฝ ๊ฐ์
## ๐ ์ฃผ์ ์กฐํญ
## โ ๏ธ ๋ฆฌ์คํฌ ๋ถ์
## ๐ผ ๊ถ๊ณ ์ฌํญ
์ฌ๋ฌด ๋ฌธ์์ฉ ํ๋กฌํํธ
๋น์ ์ ๊ณต์ธํ๊ณ์ฌ(CPA)์
๋๋ค. ๋ค์ ์ฌ๋ฌด์ ํ๋ฅผ ๋ถ์ํด์ฃผ์ธ์.
๋ถ์ ํฌ์ธํธ:
1. ์ฃผ์ ์ฌ๋ฌด ์งํ (๋งค์ถ, ์์
์ด์ต, ์์ด์ต ๋ฑ)
2. ์ ๋
๋๋น ์ฆ๊ฐ๋ฅ
3. ์ฌ๋ฌด ๊ฑด์ ์ฑ (๋ถ์ฑ๋น์จ, ์ ๋๋น์จ ๋ฑ)
4. ์์ต์ฑ ์งํ (ROE, ROA ๋ฑ)
5. ํน์ด์ฌํญ ๋ฐ ์ฃผ์์
[์ฌ๋ฌด์ ํ]
{text}
๋ค์ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
## ๐ฐ ์ฌ๋ฌด ํ์ด๋ผ์ดํธ
## ๐ ์ฃผ์ ์งํ ๋ถ์
## ๐ ์ ๋
๋๋น ๋ณํ
## โ ๏ธ ์ฃผ์์ฌํญ
## ๐ ์ข
ํฉ ํ๊ฐ
์๋ฃ ๊ธฐ๋ก์ฉ ํ๋กฌํํธ
๋น์ ์ ์๋ฃ ๊ธฐ๋ก ์ ๋ฌธ๊ฐ์
๋๋ค. ๋ค์ ํ์ ๊ธฐ๋ก์ ์์ฝํด์ฃผ์ธ์.
์ค์ ์ ๋ณด:
1. ํ์ ๊ธฐ๋ณธ ์ ๋ณด (๋์ด, ์ฑ๋ณ)
2. ์ฃผ ์ฆ์ ๋ฐ ์ง๋จ๋ช
3. ์ฒ๋ฐฉ ์ฝ๋ฌผ ๋ฐ ์ฉ๋
4. ์๋ ๋ฅด๊ธฐ ์ ๋ณด
5. ๊ณผ๊ฑฐ ๋ณ๋ ฅ
6. ํน๋ณ ์ฃผ์์ฌํญ
[์๋ฃ ๊ธฐ๋ก]
{text}
๋ค์ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
## ๐ค ํ์ ์ ๋ณด
## ๐ฅ ์ง๋จ ๋ฐ ์น๋ฃ
## ๐ ์ฒ๋ฐฉ ๋ด์ญ
## โ ๏ธ ์ฃผ์์ฌํญ
## ๐ ํ์ ์กฐ์น
๐ฅ ๊ณ ๊ธ ํ๋กฌํํธ ๊ธฐ๋ฒ
1. Chain of Thought (์ฌ๊ณ ์ ์ฐ์)
๋ณต์กํ ๋ฌธ์๋ ๋จ๊ณ๋ณ๋ก ๋ถ์ํ๊ฒ ํ๋ฉด ๋ ์ ํํด์!
๋ค์ ๋ฌธ์๋ฅผ ๋จ๊ณ๋ณ๋ก ๋ถ์ํด์ฃผ์ธ์:
Step 1: ๋ฌธ์์ ์ ์ฒด ๊ตฌ์กฐ๋ฅผ ํ์
ํ์ธ์.
Step 2: ๊ฐ ์น์
์ ํต์ฌ ๋ด์ฉ์ ์ถ์ถํ์ธ์.
Step 3: ์น์
๊ฐ์ ๊ด๊ณ์ ๋
ผ๋ฆฌ์ ํ๋ฆ์ ๋ถ์ํ์ธ์.
Step 4: ์ต์ข
์์ฝ์ ์์ฑํ์ธ์.
๊ฐ ๋จ๊ณ์ ๋ถ์ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ , ๋ง์ง๋ง์ ์ข
ํฉ ์์ฝ์ ์ ๊ณตํด์ฃผ์ธ์.
2. Few-Shot Learning (์์ ์ ๊ณต)
์ํ๋ ํ์์ ์์๋ฅผ ๋ณด์ฌ์ฃผ๋ฉด ๊ทธ๋๋ก ๋ฐ๋ผํด์!
๋ค์์ ์ข์ ์์ฝ์ ์์์
๋๋ค:
[์์ ์
๋ ฅ]
"ABC ํ์ฌ๋ 2023๋
๋งค์ถ 100์ต์, ์์
์ด์ต 10์ต์์ ๊ธฐ๋กํ๋ค..."
[์์ ์ถ๋ ฅ]
## ๐ ํต์ฌ ์งํ
- ๋งค์ถ: 100์ต์ (์ ๋
๋๋น +20%)
- ์์
์ด์ต: 10์ต์ (์์
์ด์ต๋ฅ 10%)
์ด์ ๋ค์ ๋ฌธ์๋ฅผ ๊ฐ์ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
{text}
3. Role Playing (์ญํ ๋ถ์ฌ)
ํน์ ์ ๋ฌธ๊ฐ ์ญํ ์ ๋ถ์ฌํ๋ฉด ๊ทธ ๊ด์ ์์ ๋ถ์ํด์!
๋น์ ์ ๋ค์ ์ธ ๊ฐ์ง ์ญํ ์ ์ํํฉ๋๋ค:
1. ์ฌ๋ฌด ๋ถ์๊ฐ: ์ซ์์ ์ฌ๋ฌด ์งํ์ ์ง์ค
2. ์ ๋ต ์ปจ์คํดํธ: ๋น์ฆ๋์ค ์ ๋ต๊ณผ ์์ฅ ๊ธฐํ ๋ถ์
3. ๋ฆฌ์คํฌ ๊ด๋ฆฌ์: ์ ์ฌ์ ์ํ ์์ ์๋ณ
๊ฐ ์ญํ ์ ๊ด์ ์์ ๋ฌธ์๋ฅผ ๋ถ์ํ๊ณ , ์ข
ํฉ ์๊ฒฌ์ ์ ์ํด์ฃผ์ธ์.
ํ๋กฌํํธ ์์ง๋์ด๋ง์ ์ ๋ง ๊น์ด ์๋ ๋ถ์ผ์์. ๊ฐ์ AI๋ผ๋ ํ๋กฌํํธ๋ฅผ ์ด๋ป๊ฒ ์์ฑํ๋๋์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ์ฒ์ฐจ๋ง๋ณ์ด๊ฑฐ๋ ์. ๊ณ์ ์คํํ๊ณ ๊ฐ์ ํด๋๊ฐ๋ ๊ฒ ์ค์ํด์! ๐ฌ
๐ ๋ง๋ฌด๋ฆฌ ๋ฐ ๋ค์ ๋จ๊ณ
์! ์ฌ๊ธฐ๊น์ง ์ค๋๋ผ ์๊ณ ๋ง์ผ์
จ์ด์! ๐
์ฐ๋ฆฌ๋ Claude API๋ฅผ ํ์ฉํด์ ์ด๋ฉ์ผ ์ฒจ๋ถํ์ผ์ ์๋์ผ๋ก ์์ฝํ๋ ์์ ํ ์์คํ
์ ๋ง๋ค์ด๋ดค์ด์. ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ถํฐ ๊ณ ๊ธ ์ต์ ํ, ๋ณด์, ๋ฐฐํฌ๊น์ง ๋ชจ๋ ๊ณผ์ ์ ๋ค๋ค์ฃ !
โ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๊ฒ๋ค
โจ Claude API์ ๊ฐ์ ๊ณผ ํ์ฉ๋ฒ
๐๏ธ ์์คํ
์ํคํ
์ฒ ์ค๊ณ
๐ป Python์ผ๋ก ์ด๋ฉ์ผ ์ฒ๋ฆฌ ๋ฐ ํ์ผ ํ์ฑ
๐ค AI ์์ฝ ์์ง ๊ตฌํ
โก ์ฑ๋ฅ ์ต์ ํ (์บ์ฑ, ๋ณ๋ ฌ ์ฒ๋ฆฌ)
๐ ๋ณด์ ๋ฐ ๊ฐ์ธ์ ๋ณด ๋ณดํธ
๐ Docker๋ฅผ ํ์ฉํ ๋ฐฐํฌ
๐ ๋ชจ๋ํฐ๋ง ๋ฐ ๋ก๊น
๐จ ํ๋กฌํํธ ์์ง๋์ด๋ง ์ฌํ
๐ ๋ค์ ๋จ๊ณ๋ก ๋์๊ฐ๊ธฐ
1. ์น ๋์๋ณด๋ ์ถ๊ฐ
Flask๋ FastAPI๋ก ์น ์ธํฐํ์ด์ค๋ฅผ ๋ง๋ค์ด์ ์์ฝ ๊ฒฐ๊ณผ๋ฅผ ๋ธ๋ผ์ฐ์ ์์ ํ์ธํ ์ ์๊ฒ ํด๋ณด์ธ์. ๊ฒ์ ๊ธฐ๋ฅ, ํํฐ๋ง, ํต๊ณ ์ฐจํธ ๋ฑ์ ์ถ๊ฐํ๋ฉด ๋ ์ ์ฉํด์ ธ์!
2. ๋ค๊ตญ์ด ์ง์
Claude๋ ์ฌ๋ฌ ์ธ์ด๋ฅผ ์ง์ํด์. ์์ด, ์ผ๋ณธ์ด, ์ค๊ตญ์ด ๋ฌธ์๋ ์๋์ผ๋ก ๊ฐ์งํด์ ์์ฝํ ์ ์๊ฒ ํ์ฅํด๋ณด์ธ์!
3. ์์ฑ ์๋ฆผ
์ค์ํ ๋ฌธ์๊ฐ ๋ค์ด์ค๋ฉด ์์ฑ์ผ๋ก ์๋ฆผ์ ๋ฐ์ ์ ์๊ฒ TTS(Text-to-Speech) ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์ธ์. ์ด์ ์ค์ด๋ ํ์ ์ค์๋ ๋ด์ฉ์ ํ์
ํ ์ ์์ด์!
4. ์๋ ๋ถ๋ฅ ๋ฐ ๋ผ์ฐํ
๋ฌธ์ ๋ด์ฉ์ ๋ถ์ํด์ ์๋์ผ๋ก ๋ด๋น์์๊ฒ ๋ฐฐ์ ํ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ฉด ์
๋ฌด ํจ์จ์ด ๋ ์ฌ๋ผ๊ฐ์!
5. ๋ชจ๋ฐ์ผ ์ฑ ์ฐ๋
React Native๋ Flutter๋ก ๋ชจ๋ฐ์ผ ์ฑ์ ๋ง๋ค์ด์ ์ธ์ ์ด๋์๋ ์์ฝ์ ํ์ธํ ์ ์๊ฒ ํด๋ณด์ธ์!
AI ์๋ํ๋ ์ ๋ง ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๊ณ ์๋ ๋ถ์ผ์์. Claude API ์ธ์๋ GPT-4, Gemini, LLaMA ๋ฑ ๋ค์ํ ๋ชจ๋ธ๋ค์ด ๋์ค๊ณ ์๊ณ , ๊ฐ๊ฐ ์ฅ๋จ์ ์ด ์์ฃ .
์ฌ๋ฌ๋ถ์ ์ํฉ์ ๋ง๋ ์ต์ ์ ์๋ฃจ์
์ ์ฐพ์์ ์ ์ฉํด๋ณด์ธ์. ๊ทธ๋ฆฌ๊ณ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ฌ๋ฌ๋ถ์ ๊ฒฝํ๊ณผ ๋
ธํ์ฐ๋ฅผ ๊ณต์ ํ๋ฉด์ ๋ค๋ฅธ ์ฌ๋๋ค์๊ฒ๋ ๋์์ ์ค ์ ์์ด์! ๐
์ด์ ์ฌ๋ฌ๋ถ์ ์
๋ฌด๋ฅผ AI๋ก ์๋ํํ ์ฐจ๋ก์์! ๐ช
์ง๋ฌธ์ด๋ ๋์์ด ํ์ํ๋ฉด ์ธ์ ๋ ์ปค๋ฎค๋ํฐ์ ๋ฌผ์ด๋ณด์ธ์! ๐ค
๐ ๋ ๋ง์ AI ์๋ํ ์ง์์ด ํ์ํ์ ๊ฐ์?
์ฌ๋ฅ๋ท์ '์ง์์ธ์ ์ฒ'์์ ๋ค์ํ AI ๊ฐ๋ฐ ๋
ธํ์ฐ๋ฅผ ํ์ธํด๋ณด์ธ์!
ํ๋ก๊ทธ๋๋ฐ๋ถํฐ AI ์์ด์ ํธ ๊ตฌ์ถ๊น์ง, ์ค์ ๊ฒฝํ์ด ๋ด๊ธด ์ง์๋ค์ด ๊ฐ๋ํด์! ๐ณ
Happy Coding! ์ฆ๊ฑฐ์ด ๊ฐ๋ฐ ๋์ธ์! ๐โจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.