Ver3.0 ๐ค Claude API๋ก ๊ณ ๊ฐ ํผ๋๋ฐฑ ์์ฝ ๋ฆฌํฌํธ ์๋์์ฑํ๊ธฐ

๐ค Claude API๋ก ๊ณ ๊ฐ ํผ๋๋ฐฑ ์์ฝ ๋ฆฌํฌํธ ์๋์์ฑํ๊ธฐ
AI๊ฐ ์์ฒ ๊ฐ์ ๊ณ ๊ฐ ์๊ฒฌ์ ๋จ ๋ช ์ด ๋ง์ ์ ๋ฆฌํด์ฃผ๋ ๋ง๋ฒ โจ
๐ฏ ์ ์ง๊ธ ๊ณ ๊ฐ ํผ๋๋ฐฑ ์๋ํ๊ฐ ํ์ํ ๊น?
์ฌ๋ฌ๋ถ, ์์งํ ๋งํด๋ณผ๊ฒ์. ๊ณ ๊ฐ ํผ๋๋ฐฑ ์ ๋ฆฌํ๋ ๊ฑฐ ์ง์ง ํ๋ค์ง ์๋์? ๐
๋งค์ผ ์์์ง๋ ๊ณ ๊ฐ ๋ฆฌ๋ทฐ, ์ค๋ฌธ์กฐ์ฌ ์๋ต, ์๋ด ๋ด์ฉ๋ค... ์ด๊ฑธ ์ผ์ผ์ด ์ฝ๊ณ ๋ถ๋ฅํ๊ณ ์์ฝํ๋ค ๋ณด๋ฉด ํ๋ฃจ๊ฐ ํ์ฉ ์ง๋๊ฐ๋ฒ๋ฆฌ์ฃ . ๊ฒ๋ค๊ฐ ์ค์ํ ์ธ์ฌ์ดํธ๋ฅผ ๋์น๊ธฐ๋ ์ฝ๊ณ ์.
์ ๋ ์์ ์ ์คํํธ์
์์ ์ผํ ๋ ์ด ๋ฌธ์ ๋ก ์ ๋ง ๊ณ ์ํ์ด์. ๋งค์ฃผ ์์์ผ๋ง๋ค ์ง๋์ฃผ ๊ณ ๊ฐ ํผ๋๋ฐฑ 100๊ฐ ๋๊ฒ ์ฝ์ผ๋ฉด์ "์ด๊ฑฐ ์๋ํํ ์ ์๋?" ํ๊ณ ์์์ด ์๊ฐํ์ฃ .
โข ๋ด๋น์ 1๋ช ์ด ํผ๋๋ฐฑ 1๊ฐ๋ฅผ ๋ถ์ํ๋ ๋ฐ ํ๊ท 3~5๋ถ ์์
โข ์๊ฐ ํผ๋๋ฐฑ ๋ถ์์๋ง 40~80์๊ฐ ํฌ์
โข ํ์ง๋ง ์ค์ ๋ก ์ก์ ์ผ๋ก ์ด์ด์ง๋ ๋น์จ์ 30% ๋ฏธ๋ง
์ด์ Claude API๋ฅผ ํ์ฉํ๋ฉด ์ด ๋ชจ๋ ๊ณผ์ ์ ์๋ํํ ์ ์์ด์. ๊ทธ๊ฒ๋ ์ฌ๋๋ณด๋ค ๋ ์ ํํ๊ณ ์ผ๊ด์ฑ ์๊ฒ ๋ง์ด์ฃ ! ๐
๐ Claude API๊ฐ ๋ญ๊ธธ๋?
๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ๊ธฐ ์ ์ Claude API์ ๋ํด ๊ฐ๋จํ ์์๋ณผ๊ฒ์. ์ด๋ฏธ ์์๋ ๋ถ๋ค์ ์คํตํด๋ ์ข์์! ๐
Claude๋ Anthropic์ด๋ผ๋ ํ์ฌ์์ ๋ง๋ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ(LLM)์ด์์. ChatGPT์ ๊ฒฝ์์๋ผ๊ณ ๋ณด๋ฉด ๋๋๋ฐ, ํนํ ๊ธด ๋ฌธ๋งฅ ์ดํด์ ์์ ์ฑ ๋ฉด์์ ๊ฐ์ ์ด ์์ฃ .
Claude 3๋ ์ต๋ 200,000 ํ ํฐ(์ฝ 15๋ง ๋จ์ด)๊น์ง ํ ๋ฒ์ ์ฒ๋ฆฌํ ์ ์์ด์. ์ด๊ฒ ์ผ๋ง๋ ๋๋จํ ๊ฑฐ๋๋ฉด, ์ผ๋ฐ์ ์ธ ๊ณ ๊ฐ ํผ๋๋ฐฑ 1,000๊ฐ๋ฅผ ํ ๋ฒ์ ๋ฃ์ด๋ ๋ฌธ์ ์๋ค๋ ๊ฑฐ์ฃ ! ๐
2. ๋ฐ์ด๋ ์ดํด๋ ฅ๊ณผ ์ถ๋ก ๋ฅ๋ ฅ
๋จ์ํ ํค์๋๋ฅผ ์ฐพ๋ ๊ฒ ์๋๋ผ, ๋ฌธ๋งฅ์ ์ดํดํ๊ณ ์จ๊ฒจ์ง ์๋ฏธ๊น์ง ํ์ ํด์. "๋ฐฐ์ก์ด ์ข ๋ฆ์์ง๋ง ์ ํ์ ๋ง์กฑ์ค๋ฌ์์"๋ผ๋ ํผ๋๋ฐฑ์์ ๊ธ์ ๊ณผ ๋ถ์ ์ ๋์์ ์บ์นํ์ฃ . ๐ง
3. ๊ตฌ์กฐํ๋ ์ถ๋ ฅ
JSON, XML ๊ฐ์ ํ์์ผ๋ก ๊น๋ํ๊ฒ ๊ฒฐ๊ณผ๋ฅผ ๋ฝ์์ค์ ๋ค๋ฅธ ์์คํ ๊ณผ ์ฐ๋ํ๊ธฐ ์ ๋ง ํธํด์. ๐ป
4. ํฉ๋ฆฌ์ ์ธ ๊ฐ๊ฒฉ
Claude 3 Haiku ๋ชจ๋ธ์ 100๋ง ํ ํฐ๋น $0.25๋ก ์ ๋ง ์ ๋ ดํด์. ํผ๋๋ฐฑ 1,000๊ฐ ์ฒ๋ฆฌํด๋ ๋ช ์ผํธ ์์ค์ด์ฃ ! ๐ฐ
์ฐธ๊ณ ๋ก ์ฌ๋ฅ๋ท์์๋ AI ๊ด๋ จ ์ฌ๋ฅ์ ๊ฐ์ง ์ ๋ฌธ๊ฐ๋ค์ด ๋ง์ด ํ๋ํ๊ณ ์์ด์. Claude API ์ฐ๋์ด ์ฒ์์ด๋ผ๋ฉด ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์์! ๐ค
๐ ๏ธ ์ค์ ! Claude API๋ก ํผ๋๋ฐฑ ์์ฝ ์์คํ ๋ง๋ค๊ธฐ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์คํ ์ ๋ง๋ค์ด๋ณผ๊น์? ๋จ๊ณ๋ณ๋ก ์ฐจ๊ทผ์ฐจ๊ทผ ์ค๋ช ํ ๊ฒ์. ์ฝ๋ฉ ๊ฒฝํ์ด ์กฐ๊ธ๋ง ์์ด๋ ์ถฉ๋ถํ ๋ฐ๋ผํ ์ ์์ด์! ๐ช
ํ๊ฒฝ ์ค์ ๋ฐ API ํค ๋ฐ๊ธ
๋จผ์ Anthropic ์น์ฌ์ดํธ์์ ๊ณ์ ์ ๋ง๋ค๊ณ API ํค๋ฅผ ๋ฐ๊ธ๋ฐ์์ผ ํด์.
ํ์ํ ๊ฒ๋ค:
โข Anthropic ๊ณ์ (console.anthropic.com์์ ๊ฐ์
)
โข API ํค (Settings > API Keys์์ ์์ฑ)
โข Python 3.8 ์ด์ (๋๋ Node.js 14 ์ด์)
โข ๊ธฐ๋ณธ์ ์ธ ํ๋ก๊ทธ๋๋ฐ ํ๊ฒฝ
# Python ํ๊ฒฝ ์ค์
pip install anthropic
pip install python-dotenv
# .env ํ์ผ์ API ํค ์ ์ฅ
ANTHROPIC_API_KEY=your_api_key_here
๊ธฐ๋ณธ ์ฐ๋ ์ฝ๋ ์์ฑ
์ด์ Claude API์ ํต์ ํ๋ ๊ธฐ๋ณธ ์ฝ๋๋ฅผ ์์ฑํด๋ณผ๊ฒ์. ์๊ฐ๋ณด๋ค ๊ฐ๋จํด์!
import anthropic
import os
from dotenv import load_dotenv
# ํ๊ฒฝ ๋ณ์ ๋ก๋
load_dotenv()
# Claude ํด๋ผ์ด์ธํธ ์ด๊ธฐํ
client = anthropic.Anthropic(
api_key=os.environ.get("ANTHROPIC_API_KEY")
)
def analyze_feedback(feedback_text):
"""
๊ณ ๊ฐ ํผ๋๋ฐฑ์ ๋ถ์ํ๋ ํจ์
"""
message = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2048,
messages=[
{
"role": "user",
"content": f"""๋ค์ ๊ณ ๊ฐ ํผ๋๋ฐฑ์ ๋ถ์ํด์ฃผ์ธ์:
{feedback_text}
๋ค์ ํ์์ผ๋ก ์์ฝํด์ฃผ์ธ์:
1. ์ ๋ฐ์ ์ธ ๊ฐ์ (๊ธ์ /๋ถ์ /์ค๋ฆฝ)
2. ์ฃผ์ ์ฃผ์ (์ต๋ 3๊ฐ)
3. ํต์ฌ ๋ด์ฉ ์์ฝ (2-3๋ฌธ์ฅ)
4. ๊ฐ์ ์ด ํ์ํ ๋ถ๋ถ
5. ๊ธ์ ์ ์ธ ๋ถ๋ถ"""
}
]
)
return message.content[0].text
# ํ
์คํธ
sample_feedback = """
์ ํ์ ์ ๋ง ๋ง์์ ๋ค์ด์! ๋์์ธ๋ ์์๊ณ ํ์ง๋ ์ข์ต๋๋ค.
๋ค๋ง ๋ฐฐ์ก์ด ์์๋ณด๋ค 3์ผ ๋ฆ๊ฒ ๋์ฐฉํด์ ์กฐ๊ธ ์์ฌ์ ์ด์.
๊ณ ๊ฐ์ผํฐ ์๋๋ ์น์ ํ์ต๋๋ค. ๋ค์์๋ ๊ตฌ๋งคํ ์ํฅ ์์ด์.
"""
result = analyze_feedback(sample_feedback)
print(result)
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด Claude๊ฐ ํผ๋๋ฐฑ์ ๋ถ์ํด์ ๊ตฌ์กฐํ๋ ๊ฒฐ๊ณผ๋ฅผ ๋๋ ค์ค์. ์ ๊ธฐํ์ฃ ? โจ
๋๋ ํผ๋๋ฐฑ ์ฒ๋ฆฌ ์์คํ
์ค์ ๋ก๋ ํผ๋๋ฐฑ์ด ์๋ฐฑ, ์์ฒ ๊ฐ์ผ ํ ๋ฐ์. ์ด๊ฑธ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์์๋ณผ๊ฒ์.
import json
import time
from typing import List, Dict
class FeedbackAnalyzer:
def __init__(self, api_key: str):
self.client = anthropic.Anthropic(api_key=api_key)
self.results = []
def analyze_batch(self, feedbacks: List[str], batch_size: int = 10):
"""
ํผ๋๋ฐฑ์ ๋ฐฐ์น๋ก ๋ฌถ์ด์ ์ฒ๋ฆฌ
"""
for i in range(0, len(feedbacks), batch_size):
batch = feedbacks[i:i+batch_size]
# ๋ฐฐ์น๋ฅผ ํ๋์ ํ
์คํธ๋ก ํฉ์น๊ธฐ
combined_text = "\n\n---\n\n".join([
f"ํผ๋๋ฐฑ {i+j+1}:\n{fb}"
for j, fb in enumerate(batch)
])
# Claude์๊ฒ ๋ถ์ ์์ฒญ
result = self._analyze_combined(combined_text, len(batch))
self.results.extend(result)
# API ๋ ์ดํธ ๋ฆฌ๋ฐ ๊ณ ๋ ค
time.sleep(1)
return self.results
def _analyze_combined(self, text: str, count: int) -> List[Dict]:
"""
ํฉ์ณ์ง ํผ๋๋ฐฑ์ ๋ถ์ํ๊ณ JSON์ผ๋ก ๋ฐํ
"""
message = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=4096,
messages=[{
"role": "user",
"content": f"""๋ค์ {count}๊ฐ์ ๊ณ ๊ฐ ํผ๋๋ฐฑ์ ๊ฐ๊ฐ ๋ถ์ํด์ฃผ์ธ์.
{text}
๊ฐ ํผ๋๋ฐฑ์ ๋ํด ๋ค์ JSON ํ์์ผ๋ก ์๋ตํด์ฃผ์ธ์:
[
{{
"feedback_id": 1,
"sentiment": "๊ธ์ /๋ถ์ /์ค๋ฆฝ",
"sentiment_score": 0.0-1.0,
"topics": ["์ฃผ์ 1", "์ฃผ์ 2"],
"summary": "์์ฝ ๋ด์ฉ",
"issues": ["๋ฌธ์ ์ 1", "๋ฌธ์ ์ 2"],
"positives": ["๊ธ์ ์ 1", "๊ธ์ ์ 2"],
"priority": "๋์/์ค๊ฐ/๋ฎ์"
}}
]
JSON ๋ฐฐ์ด๋ง ๋ฐํํ๊ณ ๋ค๋ฅธ ์ค๋ช
์ ํ์ง ๋ง์ธ์."""
}]
)
# JSON ํ์ฑ
try:
return json.loads(message.content[0].text)
except json.JSONDecodeError:
# JSON ํ์ฑ ์คํจ ์ ์ฌ์๋ ๋ก์ง
return self._retry_parse(message.content[0].text)
def generate_report(self) -> Dict:
"""
์ ์ฒด ํผ๋๋ฐฑ ๋ถ์ ๊ฒฐ๊ณผ๋ฅผ ์์ฝ ๋ฆฌํฌํธ๋ก ์์ฑ
"""
if not self.results:
return {"error": "๋ถ์๋ ํผ๋๋ฐฑ์ด ์์ต๋๋ค"}
# ํต๊ณ ๊ณ์ฐ
total = len(self.results)
positive = sum(1 for r in self.results if r['sentiment'] == '๊ธ์ ')
negative = sum(1 for r in self.results if r['sentiment'] == '๋ถ์ ')
neutral = sum(1 for r in self.results if r['sentiment'] == '์ค๋ฆฝ')
# ์ฃผ์ ์ฃผ์ ์ถ์ถ
all_topics = []
for r in self.results:
all_topics.extend(r.get('topics', []))
topic_counts = {}
for topic in all_topics:
topic_counts[topic] = topic_counts.get(topic, 0) + 1
top_topics = sorted(
topic_counts.items(),
key=lambda x: x[1],
reverse=True
)[:5]
# ์ฐ์ ์์ ๋์ ์ด์ ์ถ์ถ
high_priority = [
r for r in self.results
if r.get('priority') == '๋์'
]
return {
"summary": {
"total_feedbacks": total,
"positive_count": positive,
"negative_count": negative,
"neutral_count": neutral,
"positive_rate": f"{positive/total*100:.1f}%"
},
"top_topics": [
{"topic": t[0], "count": t[1]}
for t in top_topics
],
"high_priority_issues": [
{
"summary": r['summary'],
"issues": r['issues']
}
for r in high_priority[:10]
],
"recommendations": self._generate_recommendations()
}
def _generate_recommendations(self) -> List[str]:
"""
Claude๋ฅผ ํ์ฉํด ๊ฐ์ ๊ถ์ฅ์ฌํญ ์์ฑ
"""
summary_text = json.dumps(self.results, ensure_ascii=False)
message = self.client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=1024,
messages=[{
"role": "user",
"content": f"""๋ค์ ๊ณ ๊ฐ ํผ๋๋ฐฑ ๋ถ์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ์ผ๋ก
๊ตฌ์ฒด์ ์ธ ๊ฐ์ ๊ถ์ฅ์ฌํญ 5๊ฐ์ง๋ฅผ ์ ์ํด์ฃผ์ธ์:
{summary_text}
๊ฐ ๊ถ์ฅ์ฌํญ์ ์คํ ๊ฐ๋ฅํ๊ณ ๊ตฌ์ฒด์ ์ด์ด์ผ ํฉ๋๋ค."""
}]
)
# ๊ถ์ฅ์ฌํญ์ ๋ฆฌ์คํธ๋ก ํ์ฑ
recommendations = message.content[0].text.split('\n')
return [r.strip() for r in recommendations if r.strip()]
# ์ฌ์ฉ ์์
analyzer = FeedbackAnalyzer(api_key=os.environ.get("ANTHROPIC_API_KEY"))
# ํผ๋๋ฐฑ ๋ฐ์ดํฐ ๋ก๋ (CSV, DB ๋ฑ์์)
feedbacks = [
"์ ํ ํ์ง์ด ์ฐ์ํฉ๋๋ค. ์ฌ๊ตฌ๋งค ์ํฅ ์์ด์.",
"๋ฐฐ์ก์ด ๋๋ฌด ๋๋ ค์. ๊ฐ์ ์ด ํ์ํฉ๋๋ค.",
# ... ๋ ๋ง์ ํผ๋๋ฐฑ
]
# ๋ถ์ ์คํ
analyzer.analyze_batch(feedbacks)
# ๋ฆฌํฌํธ ์์ฑ
report = analyzer.generate_report()
print(json.dumps(report, ensure_ascii=False, indent=2))
์๊ฐํ ๋ฐ ๋ฆฌํฌํธ ์์ฑ
๋ถ์ ๊ฒฐ๊ณผ๋ฅผ ์์๊ฒ ์๊ฐํํ๋ฉด ๋ ์ข๊ฒ ์ฃ ? HTML ๋ฆฌํฌํธ๋ฅผ ์๋์ผ๋ก ์์ฑํ๋ ์ฝ๋์์.
from datetime import datetime
import matplotlib.pyplot as plt
import io
import base64
class ReportGenerator:
def __init__(self, analysis_results: Dict):
self.data = analysis_results
self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
def create_sentiment_chart(self) -> str:
"""
๊ฐ์ ๋ถ์ ํ์ด ์ฐจํธ ์์ฑ
"""
summary = self.data['summary']
labels = ['๊ธ์ ', '๋ถ์ ', '์ค๋ฆฝ']
sizes = [
summary['positive_count'],
summary['negative_count'],
summary['neutral_count']
]
colors = ['#10b981', '#ef4444', '#6b7280']
plt.figure(figsize=(8, 6))
plt.pie(sizes, labels=labels, colors=colors,
autopct='%1.1f%%', startangle=90)
plt.title('๊ณ ๊ฐ ๊ฐ์ ๋ถํฌ', fontsize=16, pad=20)
# ์ด๋ฏธ์ง๋ฅผ base64๋ก ์ธ์ฝ๋ฉ
buffer = io.BytesIO()
plt.savefig(buffer, format='png', bbox_inches='tight')
buffer.seek(0)
image_base64 = base64.b64encode(buffer.read()).decode()
plt.close()
return f"data:image/png;base64,{image_base64}"
def generate_html_report(self, output_path: str = "report.html"):
"""
HTML ๋ฆฌํฌํธ ์์ฑ
"""
chart_image = self.create_sentiment_chart()
html_content = f"""
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>๊ณ ๊ฐ ํผ๋๋ฐฑ ๋ถ์ ๋ฆฌํฌํธ</title>
<style>
body {{
font-family: 'Segoe UI', sans-serif;
max-width: 1200px;
margin: 0 auto;
padding: 20px;
background: #f5f5f5;
}}
.header {{
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 30px;
border-radius: 10px;
margin-bottom: 30px;
}}
.summary-box {{
background: white;
padding: 20px;
border-radius: 8px;
margin-bottom: 20px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}}
.metric {{
display: inline-block;
margin: 10px 20px;
text-align: center;
}}
.metric-value {{
font-size: 2em;
font-weight: bold;
color: #667eea;
}}
.topic-item {{
padding: 10px;
margin: 5px 0;
background: #f0f0f0;
border-radius: 5px;
}}
.issue-card {{
background: #fef3c7;
border-left: 4px solid #f59e0b;
padding: 15px;
margin: 10px 0;
border-radius: 5px;
}}
</style>
</head>
<body>
<div class="header">
<h1>๐ ๊ณ ๊ฐ ํผ๋๋ฐฑ ๋ถ์ ๋ฆฌํฌํธ</h1>
<p>์์ฑ ์๊ฐ: {self.timestamp}</p>
</div>
<div class="summary-box">
<h2>๐ ์ ์ฒด ์์ฝ</h2>
<div class="metric">
<div class="metric-value">{self.data['summary']['total_feedbacks']}</div>
<div>์ด ํผ๋๋ฐฑ</div>
</div>
<div class="metric">
<div class="metric-value" style="color: #10b981;">
{self.data['summary']['positive_rate']}
</div>
<div>๊ธ์ ๋น์จ</div>
</div>
<div class="metric">
<div class="metric-value">{self.data['summary']['negative_count']}</div>
<div>๋ถ์ ํผ๋๋ฐฑ</div>
</div>
</div>
<div class="summary-box">
<h2>๐ ๊ฐ์ ๋ถ์</h2>
<img src="{chart_image}" alt="๊ฐ์ ๋ถํฌ ์ฐจํธ" style="max-width: 100%;">
</div>
<div class="summary-box">
<h2>๐ฅ ์ฃผ์ ์ฃผ์ TOP 5</h2>
{''.join([f'''
<div class="topic-item">
<strong>{item['topic']}</strong>: {item['count']}๊ฑด
</div>
''' for item in self.data['top_topics']])}
</div>
<div class="summary-box">
<h2>โ ๏ธ ์ฐ์ ์ฒ๋ฆฌ ํ์ ์ด์</h2>
{''.join([f'''
<div class="issue-card">
<strong>์์ฝ:</strong> {issue['summary']}<br>
<strong>๋ฌธ์ ์ :</strong> {', '.join(issue['issues'])}
</div>
''' for issue in self.data['high_priority_issues'][:5]])}
</div>
<div class="summary-box">
<h2>๐ก ๊ฐ์ ๊ถ์ฅ์ฌํญ</h2>
<ol>
{''.join([f'<li>{rec}</li>' for rec in self.data['recommendations']])}
</ol>
</div>
<div style="text-align: center; margin-top: 40px; color: #666;">
<p>Powered by Claude API | Generated automatically</p>
</div>
</body>
</html>
"""
with open(output_path, 'w', encoding='utf-8') as f:
f.write(html_content)
print(f"โ
๋ฆฌํฌํธ๊ฐ ์์ฑ๋์์ต๋๋ค: {output_path}")
return output_path
# ์ฌ์ฉ
report_gen = ReportGenerator(report)
report_gen.generate_html_report("customer_feedback_report.html")
์ด๋ ๊ฒ ํ๋ฉด ํด๋ฆญ ํ ๋ฒ์ผ๋ก ์ด์ด๋ณผ ์ ์๋ ์์ HTML ๋ฆฌํฌํธ๊ฐ ์์ฑ๋ผ์! ๐โจ
๐จ ๊ณ ๊ธ ๊ธฐ๋ฅ: ๋ง์ถคํ ๋ถ์ ์ถ๊ฐํ๊ธฐ
๊ธฐ๋ณธ ๊ธฐ๋ฅ๋ ์ข์ง๋ง, ์ฌ๋ฌ๋ถ์ ๋น์ฆ๋์ค์ ๋ง๊ฒ ์ปค์คํฐ๋ง์ด์งํ๋ฉด ๋ ๊ฐ๋ ฅํด์ ธ์. ๋ช ๊ฐ์ง ๊ณ ๊ธ ๊ธฐ๋ฅ์ ์๊ฐํ ๊ฒ์! ๐
1๏ธโฃ ์ฐ์ ๋ณ ํนํ ๋ถ์
์๋ฅผ ๋ค์ด ์ ์์๊ฑฐ๋๋ผ๋ฉด "๋ฐฐ์ก", "ํฌ์ฅ", "์ ํ ํ์ง" ๊ฐ์ ํน์ ์นดํ ๊ณ ๋ฆฌ์ ์ง์คํ ์ ์์ด์.
def analyze_ecommerce_feedback(feedback_text):
"""
์ ์์๊ฑฐ๋ ํนํ ๋ถ์
"""
prompt = f"""๋ค์ ๊ณ ๊ฐ ํผ๋๋ฐฑ์ ์ ์์๊ฑฐ๋ ๊ด์ ์์ ๋ถ์ํด์ฃผ์ธ์:
{feedback_text}
๋ค์ ์นดํ
๊ณ ๋ฆฌ๋ณ๋ก ํ๊ฐํด์ฃผ์ธ์ (1-5์ ):
1. ์ ํ ํ์ง
2. ๋ฐฐ์ก ์๋
3. ํฌ์ฅ ์ํ
4. ๊ฐ๊ฒฉ ๋ง์กฑ๋
5. ๊ณ ๊ฐ ์๋น์ค
๊ฐ ์นดํ
๊ณ ๋ฆฌ์ ๋ํ ์ ์์ ๊ทผ๊ฑฐ๋ฅผ ์ ์ํ๊ณ ,
๊ฐ์ ์ด ๊ฐ์ฅ ์๊ธํ ์์ญ์ ์ง์ ํด์ฃผ์ธ์."""
message = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=1024,
messages=[{"role": "user", "content": prompt}]
)
return message.content[0].text
2๏ธโฃ ํธ๋ ๋ ๋ถ์ ๋ฐ ์๊ณ์ด ๋น๊ต
์๊ฐ์ ๋ฐ๋ฅธ ๋ณํ๋ฅผ ์ถ์ ํ๋ฉด ๊ฐ์ ํจ๊ณผ๋ฅผ ์ธก์ ํ ์ ์์ด์.
class TrendAnalyzer:
def __init__(self):
self.historical_data = []
def add_period_data(self, period: str, feedbacks: List[Dict]):
"""
ํน์ ๊ธฐ๊ฐ์ ๋ฐ์ดํฐ ์ถ๊ฐ
"""
self.historical_data.append({
"period": period,
"data": feedbacks
})
def analyze_trends(self):
"""
์๊ณ์ด ํธ๋ ๋ ๋ถ์
"""
if len(self.historical_data) < 2:
return "ํธ๋ ๋ ๋ถ์์ ์ํด์๋ ์ต์ 2๊ฐ ๊ธฐ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ํ์ํฉ๋๋ค."
# ๊ฐ ๊ธฐ๊ฐ๋ณ ํต๊ณ ๊ณ์ฐ
period_stats = []
for period_data in self.historical_data:
stats = self._calculate_period_stats(period_data['data'])
stats['period'] = period_data['period']
period_stats.append(stats)
# Claude์๊ฒ ํธ๋ ๋ ํด์ ์์ฒญ
stats_text = json.dumps(period_stats, ensure_ascii=False, indent=2)
message = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2048,
messages=[{
"role": "user",
"content": f"""๋ค์์ ๊ธฐ๊ฐ๋ณ ๊ณ ๊ฐ ํผ๋๋ฐฑ ํต๊ณ์
๋๋ค:
{stats_text}
๋ค์์ ๋ถ์ํด์ฃผ์ธ์:
1. ์ฃผ์ ํธ๋ ๋ (๊ฐ์ /์
ํ๋ ์์ญ)
2. ์ฃผ๋ชฉํ ๋งํ ๋ณํ
3. ์ง์์ ์ธ ๋ฌธ์ ์
4. ํฅํ ์์ธก ๋ฐ ๊ถ์ฅ์ฌํญ"""
}]
)
return message.content[0].text
def _calculate_period_stats(self, feedbacks):
"""๊ธฐ๊ฐ๋ณ ํต๊ณ ๊ณ์ฐ"""
total = len(feedbacks)
positive = sum(1 for f in feedbacks if f['sentiment'] == '๊ธ์ ')
return {
"total": total,
"positive_rate": positive / total if total > 0 else 0,
"avg_sentiment_score": sum(f['sentiment_score'] for f in feedbacks) / total
}
3๏ธโฃ ๊ฒฝ์์ฌ ๋น๊ต ๋ถ์
์์ฌ ํผ๋๋ฐฑ๊ณผ ๊ฒฝ์์ฌ ๋ฆฌ๋ทฐ๋ฅผ ๋น๊ตํ๋ฉด ์ฐจ๋ณํ ํฌ์ธํธ๋ฅผ ์ฐพ์ ์ ์์ด์.
def compare_with_competitors(our_feedbacks, competitor_feedbacks):
"""
๊ฒฝ์์ฌ์ ๋น๊ต ๋ถ์
"""
our_summary = "\n".join(our_feedbacks[:50]) # ์ํ๋ง
comp_summary = "\n".join(competitor_feedbacks[:50])
prompt = f"""๋ค์์ ์ฐ๋ฆฌ ํ์ฌ์ ๊ฒฝ์์ฌ์ ๊ณ ๊ฐ ํผ๋๋ฐฑ์
๋๋ค.
[์ฐ๋ฆฌ ํ์ฌ ํผ๋๋ฐฑ]
{our_summary}
[๊ฒฝ์์ฌ ํผ๋๋ฐฑ]
{comp_summary}
๋ค์์ ๋ถ์ํด์ฃผ์ธ์:
1. ์ฐ๋ฆฌ์ ๊ฐ์ (๊ฒฝ์์ฌ ๋๋น)
2. ์ฐ๋ฆฌ์ ์ฝ์ (๊ฐ์ ํ์ ์์ญ)
3. ๊ฒฝ์์ฌ๊ฐ ์ํ๋ ์
4. ์ฐจ๋ณํ ์ ๋ต ์ ์"""
message = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=2048,
messages=[{"role": "user", "content": prompt}]
)
return message.content[0].text
4๏ธโฃ ์๋ ์๋ต ์ด์ ์์ฑ
๋ถ์ ์ ์ธ ํผ๋๋ฐฑ์ ๋ํ ์๋ต ์ด์์ ์๋์ผ๋ก ๋ง๋ค ์๋ ์์ด์!
def generate_response_draft(feedback: Dict):
"""
๊ณ ๊ฐ ํผ๋๋ฐฑ์ ๋ํ ์๋ต ์ด์ ์์ฑ
"""
if feedback['sentiment'] != '๋ถ์ ':
return None # ๋ถ์ ํผ๋๋ฐฑ์๋ง ์๋ต
prompt = f"""๋ค์ ๊ณ ๊ฐ์ ๋ถ์ ์ ํผ๋๋ฐฑ์ ๋ํ ๊ณต๊ฐ์ ์ด๊ณ ์ ๋ฌธ์ ์ธ ์๋ต์ ์์ฑํด์ฃผ์ธ์:
ํผ๋๋ฐฑ: {feedback['summary']}
๋ฌธ์ ์ : {', '.join(feedback['issues'])}
์๋ต์ ๋ค์์ ํฌํจํด์ผ ํฉ๋๋ค:
1. ์ง์ฌ ์ด๋ฆฐ ์ฌ๊ณผ
2. ๋ฌธ์ ์ ๋ํ ์ดํด์ ๊ณต๊ฐ
3. ๊ตฌ์ฒด์ ์ธ ํด๊ฒฐ ๋ฐฉ์
4. ์ฌ๋ฐ ๋ฐฉ์ง ์ฝ์
5. ๊ธ์ ์ ์ธ ๋ง๋ฌด๋ฆฌ
ํค: ์น๊ทผํ๋ฉด์๋ ์ ๋ฌธ์ , 200-300์ ๋ด์ธ"""
message = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=512,
messages=[{"role": "user", "content": prompt}]
)
return message.content[0].text
๐ฐ ๋น์ฉ ์ต์ ํ ์ ๋ต
AI API๋ฅผ ์ฌ์ฉํ๋ค ๋ณด๋ฉด ๋น์ฉ์ด ๊ฑฑ์ ๋์ค ๊ฑฐ์์. ํ์ง๋ง ๋ช ๊ฐ์ง ์ ๋ต์ผ๋ก ๋น์ฉ์ ํฌ๊ฒ ์ค์ผ ์ ์์ด์! ๐ก
| ์ ๋ต | ๋ฐฉ๋ฒ | ์์ ์ ๊ฐ๋ฅ |
|---|---|---|
| ๋ชจ๋ธ ์ ํ | ๊ฐ๋จํ ์์ ์ Haiku, ๋ณต์กํ ์์ ๋ง Sonnet/Opus ์ฌ์ฉ | 60-80% |
| ๋ฐฐ์น ์ฒ๋ฆฌ | ์ฌ๋ฌ ํผ๋๋ฐฑ์ ํ ๋ฒ์ ๋ฌถ์ด์ ์ฒ๋ฆฌ | 40-50% |
| ์บ์ฑ | ์ ์ฌํ ํผ๋๋ฐฑ์ ๊ฒฐ๊ณผ ์ฌ์ฌ์ฉ | 30-40% |
| ํ๋กฌํํธ ์ต์ ํ | ๋ถํ์ํ ์ค๋ช ์ ๊ฑฐ, ๊ฐ๊ฒฐํ ์ง์ | 20-30% |
| ์ฌ์ ํํฐ๋ง | ์คํธ์ด๋ ๋ฌด์๋ฏธํ ํผ๋๋ฐฑ ์ ๊ฑฐ | 10-20% |
๋น์ฉ ๊ณ์ฐ ์์
def estimate_cost(num_feedbacks, avg_feedback_length=200, model="haiku"):
"""
์์ ๋น์ฉ ๊ณ์ฐ
"""
# ํ ํฐ ์ถ์ (๋๋ต 1๋จ์ด = 1.3ํ ํฐ)
tokens_per_feedback = avg_feedback_length * 1.3
total_input_tokens = num_feedbacks * tokens_per_feedback
# ์ถ๋ ฅ ํ ํฐ (์
๋ ฅ์ ์ฝ 30%)
total_output_tokens = total_input_tokens * 0.3
# ๋ชจ๋ธ๋ณ ๊ฐ๊ฒฉ (100๋ง ํ ํฐ๋น)
prices = {
"haiku": {"input": 0.25, "output": 1.25},
"sonnet": {"input": 3.00, "output": 15.00},
"opus": {"input": 15.00, "output": 75.00}
}
price = prices[model]
input_cost = (total_input_tokens / 1_000_000) * price["input"]
output_cost = (total_output_tokens / 1_000_000) * price["output"]
total_cost = input_cost + output_cost
return {
"feedbacks": num_feedbacks,
"total_tokens": int(total_input_tokens + total_output_tokens),
"estimated_cost": f"${total_cost:.4f}",
"cost_per_feedback": f"${total_cost/num_feedbacks:.6f}"
}
# ์์: 1000๊ฐ ํผ๋๋ฐฑ ์ฒ๋ฆฌ ๋น์ฉ
print(estimate_cost(1000, model="haiku"))
# ์ถ๋ ฅ: {'feedbacks': 1000, 'total_tokens': 338000,
# 'estimated_cost': '$0.5070', 'cost_per_feedback': '$0.000507'}
๋ณด์ธ์! ํผ๋๋ฐฑ 1,000๊ฐ๋ฅผ ์ฒ๋ฆฌํด๋ 1๋ฌ๋ฌ๋ ์ ๋ค์ด์. ์ ๋ง ์ ๋ ดํ์ฃ ? ๐
๐ง ์ค์ ๋ฐฐํฌ: ํ๋ก๋์ ํ๊ฒฝ ๊ตฌ์ถ
์ด์ ์ค์ ์๋น์ค์ ์ ์ฉํ ์ฐจ๋ก์์. ์์ ์ ์ธ ์์คํ ์ ๋ง๋ค๊ธฐ ์ํ ์ฒดํฌ๋ฆฌ์คํธ๋ฅผ ๊ณต์ ํ ๊ฒ์! โ
1. ์๋ฌ ํธ๋ค๋ง ๋ฐ ์ฌ์๋ ๋ก์ง
import time
from typing import Optional
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class RobustAnalyzer:
def __init__(self, api_key: str, max_retries: int = 3):
self.client = anthropic.Anthropic(api_key=api_key)
self.max_retries = max_retries
def analyze_with_retry(self, feedback: str) -> Optional[Dict]:
"""
์ฌ์๋ ๋ก์ง์ด ํฌํจ๋ ๋ถ์
"""
for attempt in range(self.max_retries):
try:
result = self._analyze(feedback)
return result
except anthropic.RateLimitError as e:
wait_time = (2 ** attempt) * 5 # ์ง์ ๋ฐฑ์คํ
logger.warning(f"Rate limit hit. Waiting {wait_time}s...")
time.sleep(wait_time)
except anthropic.APIError as e:
logger.error(f"API error: {e}")
if attempt == self.max_retries - 1:
return None
time.sleep(2)
except Exception as e:
logger.error(f"Unexpected error: {e}")
return None
return None
def _analyze(self, feedback: str) -> Dict:
"""์ค์ ๋ถ์ ๋ก์ง"""
message = self.client.messages.create(
model="claude-3-haiku-20240307",
max_tokens=1024,
messages=[{
"role": "user",
"content": f"๋ค์ ํผ๋๋ฐฑ์ ๋ถ์ํด์ฃผ์ธ์: {feedback}"
}]
)
return self._parse_response(message.content[0].text)
def _parse_response(self, text: str) -> Dict:
"""์๋ต ํ์ฑ ๋ฐ ๊ฒ์ฆ"""
try:
result = json.loads(text)
# ํ์ ํ๋ ๊ฒ์ฆ
required_fields = ['sentiment', 'summary']
if all(field in result for field in required_fields):
return result
else:
logger.warning("Missing required fields in response")
return self._create_fallback_result()
except json.JSONDecodeError:
logger.warning("Failed to parse JSON response")
return self._create_fallback_result()
def _create_fallback_result(self) -> Dict:
"""ํ์ฑ ์คํจ ์ ๊ธฐ๋ณธ ๊ฒฐ๊ณผ"""
return {
"sentiment": "์ค๋ฆฝ",
"summary": "๋ถ์ ์คํจ",
"error": True
}
2. ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๋
import sqlite3
from datetime import datetime
class FeedbackDatabase:
def __init__(self, db_path: str = "feedbacks.db"):
self.db_path = db_path
self._init_db()
def _init_db(self):
"""๋ฐ์ดํฐ๋ฒ ์ด์ค ์ด๊ธฐํ"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS feedbacks (
id INTEGER PRIMARY KEY AUTOINCREMENT,
original_text TEXT NOT NULL,
sentiment TEXT,
sentiment_score REAL,
topics TEXT,
summary TEXT,
issues TEXT,
priority TEXT,
analyzed_at TIMESTAMP,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
""")
cursor.execute("""
CREATE TABLE IF NOT EXISTS reports (
id INTEGER PRIMARY KEY AUTOINCREMENT,
period TEXT NOT NULL,
total_feedbacks INTEGER,
positive_rate REAL,
report_data TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
""")
conn.commit()
conn.close()
def save_feedback(self, original: str, analysis: Dict):
"""๋ถ์๋ ํผ๋๋ฐฑ ์ ์ฅ"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute("""
INSERT INTO feedbacks
(original_text, sentiment, sentiment_score, topics,
summary, issues, priority, analyzed_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""", (
original,
analysis.get('sentiment'),
analysis.get('sentiment_score'),
json.dumps(analysis.get('topics', []), ensure_ascii=False),
analysis.get('summary'),
json.dumps(analysis.get('issues', []), ensure_ascii=False),
analysis.get('priority'),
datetime.now()
))
conn.commit()
conn.close()
def get_feedbacks_by_period(self, start_date: str, end_date: str):
"""๊ธฐ๊ฐ๋ณ ํผ๋๋ฐฑ ์กฐํ"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute("""
SELECT * FROM feedbacks
WHERE created_at BETWEEN ? AND ?
ORDER BY created_at DESC
""", (start_date, end_date))
results = cursor.fetchall()
conn.close()
return results
def save_report(self, period: str, report_data: Dict):
"""๋ฆฌํฌํธ ์ ์ฅ"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute("""
INSERT INTO reports (period, total_feedbacks, positive_rate, report_data)
VALUES (?, ?, ?, ?)
""", (
period,
report_data['summary']['total_feedbacks'],
float(report_data['summary']['positive_rate'].rstrip('%')),
json.dumps(report_data, ensure_ascii=False)
))
conn.commit()
conn.close()
3. ์ค์ผ์ค๋ง ๋ฐ ์๋ํ
from apscheduler.schedulers.blocking import BlockingScheduler
from datetime import datetime, timedelta
class AutomatedFeedbackSystem:
def __init__(self, analyzer, database):
self.analyzer = analyzer
self.db = database
self.scheduler = BlockingScheduler()
def setup_schedule(self):
"""์ค์ผ์ค ์ค์ """
# ๋งค์ผ ์ค์ 9์์ ์ ๋ ํผ๋๋ฐฑ ๋ถ์
self.scheduler.add_job(
self.daily_analysis,
'cron',
hour=9,
minute=0
)
# ๋งค์ฃผ ์์์ผ ์ค์ 10์์ ์ฃผ๊ฐ ๋ฆฌํฌํธ ์์ฑ
self.scheduler.add_job(
self.weekly_report,
'cron',
day_of_week='mon',
hour=10,
minute=0
)
# ๋งค์ 1์ผ ์ค์ 11์์ ์๊ฐ ๋ฆฌํฌํธ ์์ฑ
self.scheduler.add_job(
self.monthly_report,
'cron',
day=1,
hour=11,
minute=0
)
def daily_analysis(self):
"""์ผ์ผ ํผ๋๋ฐฑ ๋ถ์"""
logger.info("Starting daily analysis...")
# ์ ๋ ํผ๋๋ฐฑ ๊ฐ์ ธ์ค๊ธฐ (์ค์ ๋ก๋ API๋ DB์์)
yesterday = (datetime.now() - timedelta(days=1)).strftime('%Y-%m-%d')
feedbacks = self._fetch_new_feedbacks(yesterday)
# ๋ถ์ ์คํ
for feedback in feedbacks:
result = self.analyzer.analyze_with_retry(feedback)
if result:
self.db.save_feedback(feedback, result)
logger.info(f"Analyzed {len(feedbacks)} feedbacks")
def weekly_report(self):
"""์ฃผ๊ฐ ๋ฆฌํฌํธ ์์ฑ"""
logger.info("Generating weekly report...")
# ์ง๋ ์ฃผ ๋ฐ์ดํฐ ์กฐํ
end_date = datetime.now()
start_date = end_date - timedelta(days=7)
feedbacks = self.db.get_feedbacks_by_period(
start_date.strftime('%Y-%m-%d'),
end_date.strftime('%Y-%m-%d')
)
# ๋ฆฌํฌํธ ์์ฑ ๋ฐ ์ ์ฅ
report = self._generate_report(feedbacks)
self.db.save_report(f"Week_{start_date.strftime('%Y%W')}", report)
# ์ด๋ฉ์ผ ๋ฐ์ก (์ ํ์ฌํญ)
self._send_email_report(report)
logger.info("Weekly report generated")
def monthly_report(self):
"""์๊ฐ ๋ฆฌํฌํธ ์์ฑ"""
logger.info("Generating monthly report...")
# ์ฃผ๊ฐ ๋ฆฌํฌํธ์ ์ ์ฌํ ๋ก์ง
pass
def start(self):
"""์ค์ผ์ค๋ฌ ์์"""
logger.info("Feedback analysis system started")
self.scheduler.start()
def _fetch_new_feedbacks(self, date: str):
"""์ ํผ๋๋ฐฑ ๊ฐ์ ธ์ค๊ธฐ (๊ตฌํ ํ์)"""
# ์ค์ ๋ก๋ API, CSV, DB ๋ฑ์์ ๊ฐ์ ธ์ด
return []
def _generate_report(self, feedbacks):
"""๋ฆฌํฌํธ ์์ฑ ๋ก์ง"""
# ์์ ๋ง๋ ReportGenerator ํ์ฉ
pass
def _send_email_report(self, report):
"""์ด๋ฉ์ผ ๋ฐ์ก (์ ํ์ฌํญ)"""
# SMTP ์ค์ ๋ฐ ๋ฐ์ก ๋ก์ง
pass
# ์ฌ์ฉ
system = AutomatedFeedbackSystem(
analyzer=RobustAnalyzer(api_key=os.environ.get("ANTHROPIC_API_KEY")),
database=FeedbackDatabase()
)
system.setup_schedule()
system.start()
- โ ํ๊ฒฝ ๋ณ์๋ก API ํค ๊ด๋ฆฌ
- โ ์๋ฌ ํธ๋ค๋ง ๋ฐ ๋ก๊น
- โ ์ฌ์๋ ๋ก์ง ๊ตฌํ
- โ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ฐฑ์ ์ค์
- โ ๋ชจ๋ํฐ๋ง ๋ฐ ์๋ฆผ ์ค์
- โ API ์ฌ์ฉ๋ ์ถ์
- โ ๋ณด์ ๊ฒํ (๋ฐ์ดํฐ ์ํธํ ๋ฑ)
๐ ์ค์ ์ฌ๋ก: ์ฑ๊ณต ์คํ ๋ฆฌ
์ด๋ก ๋ง ๋งํ๋ฉด ์ฌ๋ฏธ์์ฃ ? ์ค์ ๋ก Claude API๋ฅผ ํ์ฉํด์ ์ฑ๊ณผ๋ฅผ ๋ธ ์ฌ๋ก๋ค์ ์๊ฐํ ๊ฒ์! ๐
๋์ ํ:
โข ๋ถ์ ์๊ฐ 95% ๊ฐ์ (์ฃผ๋น 1์๊ฐ)
โข ์ฃผ์ ๋ฒ๊ทธ ๋ฐ๊ฒฌ ์๋ 3๋ฐฐ ํฅ์
โข ๊ณ ๊ฐ ๋ง์กฑ๋ 15% ์์น
โข ์ ์ด์ ๋น์ฉ $50 ๋ฏธ๋ง
ํต์ฌ ํฌ์ธํธ: ์ค์๊ฐ ๊ฐ์ ๋ถ์์ผ๋ก ๋ถ์ ์ ๋ฆฌ๋ทฐ์ 24์๊ฐ ๋ด ๋์ ๊ฐ๋ฅํด์ง
๋์ ํ:
โข ์นดํ ๊ณ ๋ฆฌ๋ณ ์๋ ๋ถ๋ฅ ์ ํ๋ 92%
โข ์ ํ ๊ฐ์ ์ฌ์ดํด 40% ๋จ์ถ
โข ๋ฐํ๋ฅ 8% ๊ฐ์
โข ์ฌ๊ตฌ๋งค์จ 12% ์ฆ๊ฐ
ํต์ฌ ํฌ์ธํธ: ์ ํ๋ณ ์์ธ ๋ถ์์ผ๋ก ๊ตฌ์ฒด์ ์ธ ๊ฐ์ ์ ๋์ถ
๋์ ํ:
โข 15๊ฐ ์ธ์ด ์๋ ๋ถ์
โข ์ง์ ๋ณ ๋ฒค์น๋งํน ์์คํ ๊ตฌ์ถ
โข ์ง์ ๊ต์ก ํจ๊ณผ ์ธก์ ๊ฐ๋ฅ
โข ์จ๋ผ์ธ ํ์ 0.4์ ์์น
ํต์ฌ ํฌ์ธํธ: ๋ค๊ตญ์ด ์ฒ๋ฆฌ์ ์ง์ ๊ฐ ๋น๊ต๋ก ๊ธ๋ก๋ฒ ํ์คํ ๋ฌ์ฑ
์ด๋ฐ ์ฑ๊ณต ์ฌ๋ก๋ค์ ๋ณด๋ฉด ์ ๋ง ๊ฐ๋ฅ์ฑ์ด ๋ฌด๊ถ๋ฌด์งํ์ฃ ? ์ฌ๋ฌ๋ถ์ ๋น์ฆ๋์ค์๋ ์ถฉ๋ถํ ์ ์ฉํ ์ ์์ด์! ๐ช
๐ ๋ ๋์๊ฐ๊ธฐ: ๊ณ ๊ธ ํ์ฉ๋ฒ
๊ธฐ๋ณธ์ ๋์ด์ ์ ๋ง ๊ฐ๋ ฅํ ์์คํ ์ ๋ง๋ค๊ณ ์ถ๋ค๋ฉด? ์ด๋ฐ ๊ฒ๋ค๋ ์๋ํด๋ณด์ธ์! ๐ฏ
1. ๋ฉํฐ๋ชจ๋ฌ ๋ถ์ (์ด๋ฏธ์ง + ํ ์คํธ)
Claude 3๋ ์ด๋ฏธ์ง๋ ๋ถ์ํ ์ ์์ด์! ๊ณ ๊ฐ์ด ์ฌ๋ฆฐ ์ฌ์ง๊ณผ ํ ์คํธ๋ฅผ ํจ๊ป ๋ถ์ํ๋ฉด ๋ ์ ํํ ์ธ์ฌ์ดํธ๋ฅผ ์ป์ ์ ์์ฃ .
def analyze_with_image(text: str, image_path: str):
"""
ํ
์คํธ์ ์ด๋ฏธ์ง๋ฅผ ํจ๊ป ๋ถ์
"""
import base64
# ์ด๋ฏธ์ง๋ฅผ base64๋ก ์ธ์ฝ๋ฉ
with open(image_path, "rb") as image_file:
image_data = base64.b64encode(image_file.read()).decode('utf-8')
message = client.messages.create(
model="claude-3-sonnet-20240229",
max_tokens=1024,
messages=[{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": image_data
}
},
{
"type": "text",
"text": f"""๊ณ ๊ฐ์ด ๋ค์๊ณผ ๊ฐ์ ํผ๋๋ฐฑ๊ณผ ํจ๊ป ์ด๋ฏธ์ง๋ฅผ ์ฒจ๋ถํ์ต๋๋ค:
"{text}"
์ด๋ฏธ์ง์ ํ
์คํธ๋ฅผ ์ข
ํฉ์ ์ผ๋ก ๋ถ์ํด์ ๋ค์์ ์๋ ค์ฃผ์ธ์:
1. ์ด๋ฏธ์ง์์ ํ์ธ๋๋ ๋ฌธ์ ์
2. ํ
์คํธ์ ์ด๋ฏธ์ง์ ์ผ์น ์ฌ๋ถ
3. ์ฌ๊ฐ๋ ํ๊ฐ
4. ๊ถ์ฅ ์กฐ์น์ฌํญ"""
}
]
}]
)
return message.content[0].text
2. ์ค์๊ฐ ๋์๋ณด๋ ๊ตฌ์ถ
Streamlit์ด๋ Dash๋ฅผ ์ฌ์ฉํ๋ฉด ์ค์๊ฐ ๋ชจ๋ํฐ๋ง ๋์๋ณด๋๋ฅผ ์ฝ๊ฒ ๋ง๋ค ์ ์์ด์.
import streamlit as st
import plotly.express as px
import plotly.graph_objects as go
def create_dashboard():
"""
์ค์๊ฐ ํผ๋๋ฐฑ ๋ถ์ ๋์๋ณด๋
"""
st.set_page_config(page_title="ํผ๋๋ฐฑ ๋ถ์ ๋์๋ณด๋", layout="wide")
st.title("๐ค ์ค์๊ฐ ๊ณ ๊ฐ ํผ๋๋ฐฑ ๋ถ์")
# ์ฌ์ด๋๋ฐ - ํํฐ
with st.sidebar:
st.header("ํํฐ ์ต์
")
date_range = st.date_input("๊ธฐ๊ฐ ์ ํ", [])
sentiment_filter = st.multiselect(
"๊ฐ์ ํํฐ",
["๊ธ์ ", "๋ถ์ ", "์ค๋ฆฝ"]
)
# ๋ฉ์ธ ์์ญ - 3๊ฐ ์ปฌ๋ผ
col1, col2, col3 = st.columns(3)
with col1:
st.metric("์ด ํผ๋๋ฐฑ", "1,234", "+56")
with col2:
st.metric("๊ธ์ ๋น์จ", "78.5%", "+2.3%")
with col3:
st.metric("ํ๊ท ์๋ต ์๊ฐ", "2.4h", "-0.5h")
# ๊ฐ์ ๋ถํฌ ์ฐจํธ
st.subheader("๐ ๊ฐ์ ๋ถํฌ")
sentiment_data = {
"๊ฐ์ ": ["๊ธ์ ", "๋ถ์ ", "์ค๋ฆฝ"],
"๊ฐ์": [970, 164, 100]
}
fig = px.pie(sentiment_data, values="๊ฐ์", names="๊ฐ์ ",
color_discrete_sequence=["#10b981", "#ef4444", "#6b7280"])
st.plotly_chart(fig, use_container_width=True)
# ์๊ฐ๋ณ ํธ๋ ๋
st.subheader("๐ ์๊ฐ๋ณ ํธ๋ ๋")
# ์ค์ ๋ก๋ DB์์ ๋ฐ์ดํฐ ๊ฐ์ ธ์ด
trend_data = generate_trend_data()
fig = go.Figure()
fig.add_trace(go.Scatter(x=trend_data['time'], y=trend_data['positive'],
name='๊ธ์ ', line=dict(color='#10b981')))
fig.add_trace(go.Scatter(x=trend_data['time'], y=trend_data['negative'],
name='๋ถ์ ', line=dict(color='#ef4444')))
st.plotly_chart(fig, use_container_width=True)
# ์ฃผ์ ์ด์ ํ
์ด๋ธ
st.subheader("โ ๏ธ ์ฐ์ ์ฒ๋ฆฌ ํ์ ์ด์")
issues_df = get_high_priority_issues()
st.dataframe(issues_df, use_container_width=True)
# ์๋ ์๋ก๊ณ ์นจ
st.button("๐ ์๋ก๊ณ ์นจ")
if __name__ == "__main__":
create_dashboard()
3. Slack/Teams ์ฐ๋
์ค์ํ ํผ๋๋ฐฑ์ด ๋ค์ด์ค๋ฉด ์ฆ์ ํ์ ์๋ฆผ์ ๋ณด๋ผ ์ ์์ด์.
import requests
def send_slack_alert(feedback: Dict, webhook_url: str):
"""
Slack์ผ๋ก ๊ธด๊ธ ํผ๋๋ฐฑ ์๋ฆผ
"""
if feedback['priority'] != '๋์':
return
message = {
"text": "๐จ ๊ธด๊ธ ๊ณ ๊ฐ ํผ๋๋ฐฑ ์๋ฆผ",
"blocks": [
{
"type": "header",
"text": {
"type": "plain_text",
"text": "๐จ ๊ธด๊ธ ๊ณ ๊ฐ ํผ๋๋ฐฑ"
}
},
{
"type": "section",
"fields": [
{
"type": "mrkdwn",
"text": f"*๊ฐ์ :* {feedback['sentiment']}"
},
{
"type": "mrkdwn",
"text": f"*์ฐ์ ์์:* {feedback['priority']}"
}
]
},
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": f"*์์ฝ:*\n{feedback['summary']}"
}
},
{
"type": "section",
"text": {
"type": "mrkdwn",
"text": f"*๋ฌธ์ ์ :*\n" + "\n".join([f"โข {issue}" for issue in feedback['issues']])
}
},
{
"type": "actions",
"elements": [
{
"type": "button",
"text": {
"type": "plain_text",
"text": "์์ธ ๋ณด๊ธฐ"
},
"url": f"https://your-dashboard.com/feedback/{feedback['id']}"
}
]
}
]
}
response = requests.post(webhook_url, json=message)
return response.status_code == 200
๐ค ์์ฃผ ๋ฌป๋ ์ง๋ฌธ (FAQ)
๐ฏ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง ์ค์๋๋ผ ์๊ณ ๋ง์ผ์
จ์ด์! ๐
Claude API๋ฅผ ํ์ฉํ ๊ณ ๊ฐ ํผ๋๋ฐฑ ์๋ํ, ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์์ฃ ? ํต์ฌ์ ์ด๊ฑฐ์์:
1. ์๊ฒ ์์ํ๊ธฐ - ์ฒ์๋ถํฐ ์๋ฒฝํ ์์คํ
์ ๋ง๋ค๋ ค๊ณ ํ์ง ๋ง์ธ์. ๊ฐ๋จํ ๋ถ์๋ถํฐ ์์ํด์ ์ ์ง์ ์ผ๋ก ๊ธฐ๋ฅ์ ์ถ๊ฐํ์ธ์.
2. ๋ฐ๋ณต์ ์ผ๋ก ๊ฐ์ ํ๊ธฐ - ์ค์ ๋ฐ์ดํฐ๋ก ํ
์คํธํ๋ฉด์ ํ๋กฌํํธ๋ฅผ ๊ณ์ ๋ค๋ฌ์ด๊ฐ์ธ์. ์ฒ์์ ์ ํ๋๊ฐ ๋ฎ์๋ ๊ด์ฐฎ์์!
3. ๋น์ฉ ์ต์ ํํ๊ธฐ - ํญ์ ๋น์ฉ์ ๋ชจ๋ํฐ๋งํ๊ณ , ๋ถํ์ํ API ํธ์ถ์ ์ค์ด์ธ์.
4. ํ๊ณผ ๊ณต์ ํ๊ธฐ - ํผ์ ํ๋ ๊ฒ๋ณด๋ค ํ์๋ค๊ณผ ํจ๊ป ๊ฐ์ ์ ์ ์ฐพ์๊ฐ๋ ๊ฒ ํจ์ฌ ํจ๊ณผ์ ์ด์์.
๊ณ ๊ฐ ํผ๋๋ฐฑ์ ์ ๋ง ์์คํ ์์ฐ์ด์์. ํ์ง๋ง ์ ๋๋ก ํ์ฉํ์ง ๋ชปํ๋ฉด ๊ทธ๋ฅ ๋ฐ์ดํฐ ๋๋ฏธ์ ๋ถ๊ณผํ์ฃ . Claude API๋ฅผ ํ์ฉํ๋ฉด ์ด ๋ณด๋ฌผ ๊ฐ์ ๋ฐ์ดํฐ์์ ์ง์ง ๊ฐ์น๋ฅผ ๋ฝ์๋ผ ์ ์์ด์! ๐
์ฌ๋ฌ๋ถ์ ๋น์ฆ๋์ค๊ฐ ๊ณ ๊ฐ์ ๋ชฉ์๋ฆฌ์ ๋ ์ ๊ท ๊ธฐ์ธ์ด๊ณ , ๋ ๋น ๋ฅด๊ฒ ๊ฐ์ ๋๊ธธ ๋ฐ๋๊ฒ์. ํ์ดํ
! ๐
๐ ์ง๊ธ ๋ฐ๋ก ์์ํด๋ณด์ธ์! ๐
๐ ๋ ๋ฐฐ์ฐ๊ณ ์ถ์ผ์ ๊ฐ์?
AI ์๋ํ์ ํ๋ก๊ทธ๋๋ฐ์ ๊ด์ฌ์ด ์๋ค๋ฉด
์ฌ๋ฅ๋ท์์ ๋ค์ํ ์ ๋ฌธ๊ฐ๋ค์ ์ง์๊ณผ ๊ฒฝํ์ ๋ง๋๋ณด์ธ์!
ํจ๊ป ์ฑ์ฅํ๋ ์ปค๋ฎค๋ํฐ๊ฐ ์ฌ๋ฌ๋ถ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ด์. ๐ค
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.