Ver3.5 LangChain + OpenAI로개인 맞춤형 이메일 생성기 만들기

LangChain + OpenAI로
개인 맞춤형 이메일 생성기 만들기
야 솔직히 말해봐 ㅋㅋㅋ 이메일 쓰는 거 진짜 귀찮지 않음?
"안녕하세요, 저는 OOO입니다. 다름이 아니오라..." 이 패턴 몇 번째 쓰는 건지 ㅠㅠ
근데 그렇다고 대충 쓰면 또 프로답지 않아 보이고... 이 딜레마 공감하는 사람 손 🙋
오늘은 LangChain이랑 OpenAI GPT를 조합해서
내 상황에 딱 맞는 이메일을 자동으로 생성해주는 시스템을 만들어볼 거야!
그냥 "이메일 써줘" 수준이 아니라, 수신자 정보, 톤앤매너, 목적까지 다 반영해서
진짜 개인화된 이메일을 뽑아내는 거임 🔥
처음부터 끝까지 다 커버함! 코드도 실제로 돌아가는 거 위주로 씀 ㅎㅎ
LangChain... 이름만 들으면 뭔가 블록체인 같은 거 아님? ㅋㅋㅋ
근데 전혀 아님! LangChain은 LLM(대형 언어 모델)을 활용한 애플리케이션을 쉽게 만들 수 있게 해주는 Python/JavaScript 프레임워크야.
쉽게 말하면 이런 거임:
OpenAI GPT 같은 AI 모델을 그냥 쓰면 "질문 → 답변" 이 단순한 구조밖에 못 씀.
근데 LangChain을 쓰면 여러 단계를 체인처럼 연결하고, 외부 데이터도 연동하고,
대화 기록도 관리하는 복잡한 AI 앱을 훨씬 쉽게 만들 수 있어!
| 컴포넌트 | 역할 | 이메일 생성기에서의 활용 |
|---|---|---|
| PromptTemplate | 프롬프트를 템플릿화해서 변수 삽입 | 수신자명, 목적 등을 동적으로 삽입 |
| LLMChain | LLM + 프롬프트를 연결하는 기본 체인 | GPT 모델과 프롬프트 연결 |
| ChatOpenAI | OpenAI 채팅 모델 래퍼 | GPT-4o 등 모델 호출 |
| OutputParser | AI 출력값을 원하는 형식으로 파싱 | 이메일 제목/본문 분리 추출 |
| Memory | 대화 히스토리 관리 | 이전 이메일 스타일 기억 |
LangChain은 이런 반복 작업을 추상화해서 비즈니스 로직에만 집중할 수 있게 해줌!
코드 짜기 전에 환경 세팅이 제일 중요함.
귀찮아도 이 단계 제대로 안 하면 나중에 에러 폭탄 맞음 ㅠㅠ
python --version 으로 확인!
유료 플랜 필요 (GPT-4o 기준 입력 $2.50/1M 토큰, 출력 $10/1M 토큰)
python -m venv email_gen_env
# 가상환경 활성화 (Windows)
email_gen_env\Scripts\activate
# 가상환경 활성화 (Mac/Linux)
source email_gen_env/bin/activate
# 필요 패키지 한 번에 설치
pip install langchain langchain-openai openai python-dotenv pydantic
API 키를 코드에 직접 박아넣으면 절대 안 됨! 깃헙에 올리는 순간 해킹당함 ㅋㅋㅋ
반드시 .env 파일로 관리하자.
# .env 파일 내용
OPENAI_API_KEY=sk-proj-여기에_본인_API_키_입력
OPENAI_MODEL=gpt-4o-mini # 비용 절약하려면 mini 추천!
echo ".env" >> .gitignore 이거 꼭 실행해줘.API 키 유출되면 요금 폭탄 맞을 수 있음... 진짜로 ㅠㅠ
코드 막 짜기 전에 구조부터 잡아야 나중에 유지보수가 편함.
이메일 생성기 프로젝트 구조는 이렇게 잡을 거야:
email_generator/
├── .env # API 키 등 환경변수
├── .gitignore # git 제외 파일 목록
├── requirements.txt # 패키지 목록
├── main.py # 메인 실행 파일
├── config.py # 설정 관리
├── email_generator/
│ ├── __init__.py
│ ├── templates.py # 프롬프트 템플릿 모음
│ ├── chains.py # LangChain 체인 구성
│ ├── models.py # 데이터 모델 (Pydantic)
│ └── generator.py # 이메일 생성 핵심 로직
└── examples/
└── sample_usage.py # 사용 예시
chains.py는 LangChain 체인 구성만, generator.py는 비즈니스 로직만 담당.
단일 책임 원칙(SRP) 지키면 코드 관리가 진짜 편해짐!
이메일 생성기에 어떤 정보가 필요한지 먼저 정의해야 함.
Pydantic 쓰면 타입 검증도 자동으로 해줘서 개꿀 ㅎㅎ
# email_generator/models.py
from pydantic import BaseModel, Field
from typing import Optional, Literal
from enum import Enum
class EmailTone(str, Enum):
"""이메일 톤 옵션"""
FORMAL = "formal" # 공식적/격식체
SEMI_FORMAL = "semi_formal" # 반격식체
FRIENDLY = "friendly" # 친근한
PERSUASIVE = "persuasive" # 설득적
APOLOGETIC = "apologetic" # 사과/유감
class EmailPurpose(str, Enum):
"""이메일 목적"""
INTRODUCTION = "introduction" # 자기소개/첫 연락
FOLLOW_UP = "follow_up" # 후속 연락
REQUEST = "request" # 요청/부탁
PROPOSAL = "proposal" # 제안
COMPLAINT = "complaint" # 불만/항의
THANK_YOU = "thank_you" # 감사
MEETING_REQUEST = "meeting_request" # 미팅 요청
CUSTOM = "custom" # 직접 입력
class RecipientInfo(BaseModel):
"""수신자 정보"""
name: str = Field(description="수신자 이름")
company: Optional[str] = Field(default=None, description="수신자 회사명")
position: Optional[str] = Field(default=None, description="수신자 직책")
relationship: str = Field(
default="처음 연락",
description="발신자와의 관계 (예: 처음 연락, 기존 거래처, 상사 등)"
)
class SenderInfo(BaseModel):
"""발신자 정보"""
name: str = Field(description="발신자 이름")
company: Optional[str] = Field(default=None, description="발신자 회사명")
position: Optional[str] = Field(default=None, description="발신자 직책")
class EmailRequest(BaseModel):
"""이메일 생성 요청 전체 정보"""
sender: SenderInfo
recipient: RecipientInfo
purpose: EmailPurpose
custom_purpose: Optional[str] = Field(
default=None,
description="purpose가 CUSTOM일 때 직접 입력하는 목적"
)
key_points: list[str] = Field(
description="이메일에 반드시 포함할 핵심 내용들"
)
tone: EmailTone = Field(default=EmailTone.SEMI_FORMAL)
language: Literal["korean", "english"] = Field(default="korean")
max_length: int = Field(
default=300,
description="이메일 본문 최대 글자 수",
ge=100, le=1000
)
class GeneratedEmail(BaseModel):
"""생성된 이메일 결과"""
subject: str = Field(description="이메일 제목")
body: str = Field(description="이메일 본문")
tone_used: str = Field(description="사용된 톤")
word_count: int = Field(description="본문 글자 수")
Pydantic 모델 쓰면 이런 장점이 있음:
- 타입이 맞지 않으면 자동으로 에러 발생 → 버그 조기 발견
- .dict(), .json() 변환이 초간단
- IDE에서 자동완성 지원 → 개발 속도 UP ⬆️
LangChain에서 프롬프트 템플릿은 AI한테 보내는 "지시서" 같은 거야.
이걸 얼마나 잘 만드냐에 따라 이메일 품질이 하늘과 땅 차이남 ㅋㅋㅋ
"너는 전문 비즈니스 이메일 작성 전문가야" 처럼 AI에게 명확한 역할을 줘야 함.
역할이 있으면 그 역할에 맞는 답변을 생성함!
"300자 이내로", "존댓말 사용", "제목과 본문을 구분해서" 같은 구체적 조건이 필요함.
AI가 어떤 형식으로 답해야 하는지 명확히 지정해야 파싱이 쉬워짐.
좋은 예시를 1~2개 보여주면 품질이 확 올라감. 진짜로!
# email_generator/templates.py
from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
# 시스템 프롬프트 - AI의 역할과 기본 지침 정의
SYSTEM_TEMPLATE = """당신은 10년 경력의 전문 비즈니스 커뮤니케이션 전문가입니다.
다양한 상황에 맞는 완벽한 이메일을 작성하는 것이 당신의 전문 분야입니다.
## 이메일 작성 원칙
1. 수신자와의 관계와 상황을 정확히 파악하여 적절한 톤을 유지합니다
2. 핵심 내용을 명확하고 간결하게 전달합니다
3. 한국 비즈니스 문화에 맞는 예의와 격식을 갖춥니다
4. 불필요한 내용은 과감히 제거합니다
## 출력 형식 (반드시 이 형식을 지켜주세요)
제목: [이메일 제목]
---
[이메일 본문]
## 톤 가이드
- formal(격식체): 처음 만나는 고위직, 공공기관 등
- semi_formal(반격식체): 일반적인 비즈니스 상황
- friendly(친근한): 친분이 있는 동료나 파트너
- persuasive(설득적): 제안이나 영업 상황
- apologetic(사과): 실수나 문제 상황"""
# 사용자 입력 프롬프트 템플릿
HUMAN_TEMPLATE = """다음 정보를 바탕으로 이메일을 작성해주세요:
## 발신자 정보
- 이름: {sender_name}
- 회사: {sender_company}
- 직책: {sender_position}
## 수신자 정보
- 이름: {recipient_name}
- 회사: {recipient_company}
- 직책: {recipient_position}
- 관계: {relationship}
## 이메일 설정
- 목적: {purpose}
- 톤: {tone}
- 최대 글자 수: {max_length}자 이내
## 반드시 포함할 핵심 내용
{key_points}
위 정보를 바탕으로 자연스럽고 효과적인 이메일을 작성해주세요.
제목과 본문을 구분하여 출력해주세요."""
def get_email_prompt_template() -> ChatPromptTemplate:
"""이메일 생성용 ChatPromptTemplate 반환"""
system_message = SystemMessagePromptTemplate.from_template(SYSTEM_TEMPLATE)
human_message = HumanMessagePromptTemplate.from_template(HUMAN_TEMPLATE)
return ChatPromptTemplate.from_messages([
system_message,
human_message
])
출력 형식을 구체적으로 지정할수록 파싱이 쉬워짐.
너무 길면 오히려 역효과 — 핵심만 담는 게 좋음!
이제 진짜 LangChain의 핵심인 체인을 구성할 차례야!
LangChain 0.2 버전부터는 LCEL (LangChain Expression Language) 방식을 권장함.
파이프(|) 연산자로 체인을 연결하는 방식인데 진짜 직관적임 ㅎㅎ
# email_generator/chains.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough
from .templates import get_email_prompt_template
load_dotenv()
def create_email_chain():
"""
이메일 생성 체인 생성
LCEL (LangChain Expression Language) 방식 사용
"""
# 1. LLM 모델 초기화
llm = ChatOpenAI(
model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
temperature=0.7, # 창의성 조절 (0=결정적, 1=창의적)
max_tokens=1000, # 최대 출력 토큰
api_key=os.getenv("OPENAI_API_KEY")
)
# 2. 프롬프트 템플릿 가져오기
prompt = get_email_prompt_template()
# 3. 출력 파서 (문자열로 변환)
output_parser = StrOutputParser()
# 4. LCEL로 체인 연결 (파이프 연산자 사용!)
# prompt → llm → output_parser 순서로 실행됨
chain = prompt | llm | output_parser
return chain
def create_email_chain_with_retry():
"""
재시도 로직이 포함된 이메일 생성 체인
API 오류 시 자동으로 재시도
"""
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
temperature=0.7,
max_tokens=1000,
api_key=os.getenv("OPENAI_API_KEY"),
max_retries=3, # 실패 시 최대 3번 재시도
request_timeout=30 # 30초 타임아웃
)
prompt = get_email_prompt_template()
output_parser = StrOutputParser()
chain = prompt | llm | output_parser
return chain
| temperature 값 | 특성 | 이메일에 적합한 상황 |
|---|---|---|
| 0.0 ~ 0.3 | 결정적, 일관성 높음 | 공식 문서, 법적 이메일 |
| 0.4 ~ 0.7 | 균형잡힌 창의성 | 일반 비즈니스 이메일 (추천!) |
| 0.8 ~ 1.0 | 창의적, 다양한 표현 | 마케팅, 창의적 제안 이메일 |
이제 진짜 핵심 부분! 모든 걸 조합해서 실제로 이메일을 생성하는 클래스를 만들 거야.
파싱 로직이랑 에러 처리까지 꼼꼼하게 넣을 거임 ㅎㅎ
# email_generator/generator.py
import re
from typing import Optional
from .models import EmailRequest, GeneratedEmail, EmailTone, EmailPurpose
from .chains import create_email_chain_with_retry
class EmailGenerator:
"""개인 맞춤형 이메일 생성기 메인 클래스"""
# 이메일 목적 한국어 매핑
PURPOSE_MAP = {
EmailPurpose.INTRODUCTION: "자기소개 및 첫 연락",
EmailPurpose.FOLLOW_UP: "후속 연락 및 진행상황 확인",
EmailPurpose.REQUEST: "요청 및 부탁",
EmailPurpose.PROPOSAL: "제안 및 협력 요청",
EmailPurpose.COMPLAINT: "불만 및 문제 제기",
EmailPurpose.THANK_YOU: "감사 인사",
EmailPurpose.MEETING_REQUEST: "미팅 요청",
EmailPurpose.CUSTOM: "기타"
}
# 톤 한국어 매핑
TONE_MAP = {
EmailTone.FORMAL: "격식체 (매우 공식적)",
EmailTone.SEMI_FORMAL: "반격식체 (일반 비즈니스)",
EmailTone.FRIENDLY: "친근한 톤",
EmailTone.PERSUASIVE: "설득적 톤",
EmailTone.APOLOGETIC: "사과/유감 톤"
}
def __init__(self):
"""생성기 초기화 - 체인 생성"""
self.chain = create_email_chain_with_retry()
print("✅ 이메일 생성기 초기화 완료!")
def _prepare_input(self, request: EmailRequest) -> dict:
"""EmailRequest를 체인 입력 형식으로 변환"""
# 목적 텍스트 결정
if request.purpose == EmailPurpose.CUSTOM and request.custom_purpose:
purpose_text = request.custom_purpose
else:
purpose_text = self.PURPOSE_MAP.get(request.purpose, "이메일 작성")
# 핵심 내용을 번호 목록으로 변환
key_points_text = "\n".join(
[f"{i+1}. {point}" for i, point in enumerate(request.key_points)]
)
return {
"sender_name": request.sender.name,
"sender_company": request.sender.company or "미입력",
"sender_position": request.sender.position or "미입력",
"recipient_name": request.recipient.name,
"recipient_company": request.recipient.company or "미입력",
"recipient_position": request.recipient.position or "미입력",
"relationship": request.recipient.relationship,
"purpose": purpose_text,
"tone": self.TONE_MAP.get(request.tone, "반격식체"),
"max_length": request.max_length,
"key_points": key_points_text
}
def _parse_output(self, raw_output: str, tone: EmailTone) -> GeneratedEmail:
"""AI 출력을 파싱하여 GeneratedEmail 객체로 변환"""
# "제목:" 패턴으로 제목 추출
subject_match = re.search(r'제목:\s*(.+?)(?:\n|$)', raw_output)
if subject_match:
subject = subject_match.group(1).strip()
# "---" 구분선 이후를 본문으로 처리
parts = raw_output.split('---', 1)
if len(parts) > 1:
body = parts[1].strip()
else:
# 구분선 없으면 제목 다음 줄부터 본문
body = raw_output[subject_match.end():].strip()
else:
# 파싱 실패 시 전체를 본문으로 처리
subject = "이메일 제목"
body = raw_output.strip()
return GeneratedEmail(
subject=subject,
body=body,
tone_used=self.TONE_MAP.get(tone, "반격식체"),
word_count=len(body)
)
def generate(self, request: EmailRequest) -> GeneratedEmail:
"""
이메일 생성 메인 메서드
Args:
request: EmailRequest 객체 (이메일 생성에 필요한 모든 정보)
Returns:
GeneratedEmail: 생성된 이메일 (제목 + 본문)
"""
print(f"📧 이메일 생성 시작... (목적: {request.purpose.value})")
# 입력 데이터 준비
chain_input = self._prepare_input(request)
# 체인 실행 (LangChain이 OpenAI API 호출)
raw_output = self.chain.invoke(chain_input)
# 출력 파싱
result = self._parse_output(raw_output, request.tone)
print(f"✅ 이메일 생성 완료! (본문 {result.word_count}자)")
return result
def generate_multiple(
self,
request: EmailRequest,
count: int = 3
) -> list[GeneratedEmail]:
"""
같은 조건으로 여러 버전의 이메일 생성
temperature가 있어서 매번 다른 결과가 나옴!
"""
results = []
for i in range(count):
print(f"버전 {i+1}/{count} 생성 중...")
result = self.generate(request)
results.append(result)
return results
이론은 충분히 했으니까 이제 진짜로 써보는 예시를 보여줄게.
다양한 상황별로 어떻게 쓰는지 보면 감이 올 거야 ㅎㅎ
# main.py
from email_generator.models import (
EmailRequest, SenderInfo, RecipientInfo,
EmailTone, EmailPurpose
)
from email_generator.generator import EmailGenerator
def example_first_contact():
"""첫 비즈니스 연락 이메일 생성 예시"""
generator = EmailGenerator()
request = EmailRequest(
sender=SenderInfo(
name="김민준",
company="테크스타트업 주식회사",
position="사업개발팀장"
),
recipient=RecipientInfo(
name="이서연",
company="글로벌파트너스",
position="파트너십 디렉터",
relationship="처음 연락"
),
purpose=EmailPurpose.PROPOSAL,
key_points=[
"AI 기반 마케팅 자동화 솔루션 협력 제안",
"당사 솔루션이 귀사의 마케팅 효율을 30% 향상시킬 수 있음",
"다음 주 중 30분 미팅 요청",
"무료 데모 세션 제공 가능"
],
tone=EmailTone.SEMI_FORMAL,
max_length=400
)
email = generator.generate(request)
print("=" * 50)
print(f"📧 제목: {email.subject}")
print("=" * 50)
print(email.body)
print("=" * 50)
print(f"📊 본문 글자 수: {email.word_count}자")
print(f"🎨 사용된 톤: {email.tone_used}")
if __name__ == "__main__":
example_first_contact()
def example_apology_email():
"""납기 지연 사과 이메일 생성 예시"""
generator = EmailGenerator()
request = EmailRequest(
sender=SenderInfo(
name="박지훈",
company="제조업체 A",
position="영업부장"
),
recipient=RecipientInfo(
name="최현우",
company="바이어 B사",
position="구매팀장",
relationship="3년 거래 파트너"
),
purpose=EmailPurpose.APOLOGETIC,
key_points=[
"원자재 수급 문제로 납기가 2주 지연됨",
"진심으로 사과드림",
"지연에 따른 보상으로 다음 주문 5% 할인 제공",
"정확한 납기일: 다음달 15일로 확정",
"재발 방지를 위한 공급망 다변화 조치 완료"
],
tone=EmailTone.APOLOGETIC,
max_length=500
)
email = generator.generate(request)
print(f"제목: {email.subject}")
print(email.body)
def example_multiple_versions():
"""같은 내용으로 3가지 버전 생성 후 비교"""
generator = EmailGenerator()
request = EmailRequest(
sender=SenderInfo(name="정수아", company="마케팅에이전시"),
recipient=RecipientInfo(
name="강태양",
company="스타트업 C",
position="대표",
relationship="SNS에서 알게 된 사이"
),
purpose=EmailPurpose.MEETING_REQUEST,
key_points=[
"SNS에서 귀사의 성장 스토리를 인상 깊게 봄",
"마케팅 전략 관련 협력 가능성 논의 희망",
"커피챗 형식의 가벼운 미팅 제안"
],
tone=EmailTone.FRIENDLY,
max_length=300
)
# 3가지 버전 생성
versions = generator.generate_multiple(request, count=3)
for i, email in enumerate(versions, 1):
print(f"\n{'='*40}")
print(f"버전 {i}")
print(f"제목: {email.subject}")
print(f"{'='*40}")
print(email.body)
이메일 생성할 때 결과가 한 번에 뚝 나오는 것보다
ChatGPT처럼 글자가 실시간으로 타이핑되는 게 훨씬 UX가 좋잖아?
LangChain에서 스트리밍 구현하는 거 진짜 쉬움 ㅎㅎ
# email_generator/streaming_generator.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from .templates import get_email_prompt_template
from .models import EmailRequest, EmailTone, EmailPurpose
load_dotenv()
class StreamingEmailGenerator:
"""스트리밍 방식으로 이메일을 실시간 출력하는 생성기"""
PURPOSE_MAP = {
EmailPurpose.INTRODUCTION: "자기소개 및 첫 연락",
EmailPurpose.FOLLOW_UP: "후속 연락",
EmailPurpose.REQUEST: "요청 및 부탁",
EmailPurpose.PROPOSAL: "제안",
EmailPurpose.COMPLAINT: "불만 제기",
EmailPurpose.THANK_YOU: "감사 인사",
EmailPurpose.MEETING_REQUEST: "미팅 요청",
EmailPurpose.CUSTOM: "기타"
}
TONE_MAP = {
EmailTone.FORMAL: "격식체",
EmailTone.SEMI_FORMAL: "반격식체",
EmailTone.FRIENDLY: "친근한 톤",
EmailTone.PERSUASIVE: "설득적 톤",
EmailTone.APOLOGETIC: "사과 톤"
}
def __init__(self):
# 스트리밍 콜백 핸들러 설정
self.streaming_handler = StreamingStdOutCallbackHandler()
# 스트리밍 모드 LLM
self.llm = ChatOpenAI(
model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
temperature=0.7,
streaming=True, # 스트리밍 활성화!
callbacks=[self.streaming_handler],
api_key=os.getenv("OPENAI_API_KEY")
)
self.prompt = get_email_prompt_template()
self.chain = self.prompt | self.llm | StrOutputParser()
def generate_stream(self, request: EmailRequest):
"""
스트리밍으로 이메일 생성
실시간으로 글자가 출력됨!
"""
if request.purpose == EmailPurpose.CUSTOM and request.custom_purpose:
purpose_text = request.custom_purpose
else:
purpose_text = self.PURPOSE_MAP.get(request.purpose, "이메일 작성")
key_points_text = "\n".join(
[f"{i+1}. {point}" for i, point in enumerate(request.key_points)]
)
chain_input = {
"sender_name": request.sender.name,
"sender_company": request.sender.company or "미입력",
"sender_position": request.sender.position or "미입력",
"recipient_name": request.recipient.name,
"recipient_company": request.recipient.company or "미입력",
"recipient_position": request.recipient.position or "미입력",
"relationship": request.recipient.relationship,
"purpose": purpose_text,
"tone": self.TONE_MAP.get(request.tone, "반격식체"),
"max_length": request.max_length,
"key_points": key_points_text
}
print("\n📧 이메일 생성 중...\n" + "="*40)
# stream() 메서드로 청크 단위 실시간 출력
full_response = ""
for chunk in self.chain.stream(chain_input):
print(chunk, end="", flush=True)
full_response += chunk
print("\n" + "="*40)
return full_response
같은 수신자한테 여러 번 이메일 보낼 때
이전에 어떤 스타일로 썼는지 기억해서 일관성 있게 유지하면 더 좋겠지?
LangChain의 ConversationBufferMemory로 구현할 수 있어!
# email_generator/memory_generator.py
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
import os
from dotenv import load_dotenv
load_dotenv()
class MemoryEmailGenerator:
"""
대화 기록을 기억하는 이메일 생성기
같은 수신자에게 보내는 이메일의 일관성 유지
"""
def __init__(self):
self.llm = ChatOpenAI(
model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
temperature=0.7,
api_key=os.getenv("OPENAI_API_KEY")
)
# 대화 기록 메모리 초기화
self.memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True
)
# 메모리를 활용하는 프롬프트 템플릿
self.prompt = PromptTemplate(
input_variables=["chat_history", "human_input"],
template="""당신은 전문 이메일 작성 어시스턴트입니다.
이전 대화 기록을 참고하여 일관된 스타일로 이메일을 작성해주세요.
이전 대화 기록:
{chat_history}
현재 요청:
{human_input}
이메일을 작성해주세요 (제목: [제목] 형식으로 시작):"""
)
# 메모리가 포함된 체인 생성
self.conversation = ConversationChain(
llm=self.llm,
memory=self.memory,
prompt=self.prompt,
verbose=False
)
def generate_with_memory(self, request_text: str) -> str:
"""
이전 대화를 기억하며 이메일 생성
Args:
request_text: 자연어로 된 이메일 요청
Returns:
생성된 이메일 텍스트
"""
response = self.conversation.predict(human_input=request_text)
return response
def clear_memory(self):
"""메모리 초기화 (새로운 수신자로 전환 시)"""
self.memory.clear()
print("🗑️ 대화 기록이 초기화되었습니다.")
def get_memory_summary(self) -> str:
"""현재 저장된 대화 기록 확인"""
messages = self.memory.chat_memory.messages
if not messages:
return "저장된 대화 기록이 없습니다."
return f"총 {len(messages)}개의 메시지가 기억에 저장되어 있습니다."
# 사용 예시
def demo_memory_usage():
gen = MemoryEmailGenerator()
# 첫 번째 이메일
email1 = gen.generate_with_memory(
"김철수 대표님께 우리 회사 AI 솔루션 소개하는 이메일 써줘. "
"친근하지만 전문적인 톤으로."
)
print("첫 번째 이메일:")
print(email1)
# 두 번째 이메일 (이전 스타일 기억!)
email2 = gen.generate_with_memory(
"김철수 대표님께 지난번 이메일 후속으로 미팅 요청하는 이메일 써줘."
)
print("\n두 번째 이메일 (이전 스타일 유지):")
print(email2)
ConversationSummaryMemory: 대화를 요약해서 저장 (긴 대화에 적합)
ConversationBufferWindowMemory: 최근 N개 대화만 저장 (메모리 절약)
이메일 생성기에는 보통 BufferWindowMemory가 가장 실용적임!
AI가 뱉는 텍스트를 그냥 쓰면 파싱이 불안정함.
LangChain의 PydanticOutputParser를 쓰면 JSON 형식으로 깔끔하게 받을 수 있어!
# email_generator/structured_generator.py
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field
import os
from dotenv import load_dotenv
load_dotenv()
class StructuredEmail(BaseModel):
"""구조화된 이메일 출력 스키마"""
subject: str = Field(description="이메일 제목 (간결하고 명확하게)")
greeting: str = Field(description="인사말 (수신자 이름 포함)")
body: str = Field(description="이메일 본문 내용")
closing: str = Field(description="마무리 인사")
signature: str = Field(description="서명 (발신자 정보)")
tone_analysis: str = Field(description="사용된 톤에 대한 간단한 설명")
class StructuredEmailGenerator:
"""Pydantic OutputParser를 활용한 구조화된 이메일 생성기"""
def __init__(self):
# PydanticOutputParser 초기화
self.parser = PydanticOutputParser(pydantic_object=StructuredEmail)
self.llm = ChatOpenAI(
model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
temperature=0.7,
api_key=os.getenv("OPENAI_API_KEY")
)
# 파서의 형식 지시사항을 프롬프트에 자동 삽입
self.prompt = PromptTemplate(
template="""당신은 전문 이메일 작성 전문가입니다.
다음 정보를 바탕으로 이메일을 작성하고, 지정된 형식으로 출력해주세요.
발신자: {sender_name} ({sender_position}, {sender_company})
수신자: {recipient_name} ({recipient_position}, {recipient_company})
목적: {purpose}
핵심 내용: {key_points}
톤: {tone}
{format_instructions}""",
input_variables=[
"sender_name", "sender_position", "sender_company",
"recipient_name", "recipient_position", "recipient_company",
"purpose", "key_points", "tone"
],
partial_variables={
# 파서가 자동으로 형식 지시사항 생성!
"format_instructions": self.parser.get_format_instructions()
}
)
# LCEL 체인 구성
self.chain = self.prompt | self.llm | self.parser
def generate(self, **kwargs) -> StructuredEmail:
"""구조화된 이메일 생성"""
result = self.chain.invoke(kwargs)
return result
# 사용 예시
def demo_structured():
gen = StructuredEmailGenerator()
email = gen.generate(
sender_name="이민호",
sender_position="개발팀장",
sender_company="AI스타트업",
recipient_name="박서준",
recipient_position="CTO",
recipient_company="대기업 B",
purpose="기술 협력 파트너십 제안",
key_points="1. API 연동 협력\n2. 공동 개발 프로젝트\n3. 수익 분배 모델 논의",
tone="semi_formal"
)
# 구조화된 결과 접근!
print(f"제목: {email.subject}")
print(f"인사말: {email.greeting}")
print(f"본문: {email.body}")
print(f"마무리: {email.closing}")
print(f"서명: {email.signature}")
print(f"톤 분석: {email.tone_analysis}")
OpenAI API 쓰면 비용이 발생하잖아.
특히 GPT-4o 쓰면 생각보다 금방 청구서가 무서워짐 ㅋㅋㅋ
스마트하게 비용 절약하는 방법들 알려줄게!
| 모델 | 입력 (1M 토큰) | 출력 (1M 토큰) | 이메일 생성기 적합도 |
|---|---|---|---|
| gpt-4o | $2.50 | $10.00 | ⭐⭐⭐⭐⭐ (최고 품질) |
| gpt-4o-mini | $0.15 | $0.60 | ⭐⭐⭐⭐ (가성비 최고!) |
| gpt-3.5-turbo | $0.50 | $1.50 | ⭐⭐⭐ (기본 이메일) |
일반 비즈니스 이메일은 mini로도 충분히 좋은 품질 나옴. gpt-4o 대비 약 17배 저렴!
2. 프롬프트 토큰 최소화
불필요한 설명 줄이고 핵심만 담으면 입력 토큰 절약됨.
3. max_tokens 적절히 설정
이메일 본문이 300자면 max_tokens=500 정도면 충분. 너무 크게 잡지 말 것!
4. 캐싱 활용
같은 요청이 반복되면 API 재호출 대신 캐시된 결과 사용.
# 캐싱 구현 예시
import hashlib
import json
from functools import lru_cache
class CachedEmailGenerator:
"""캐싱으로 비용 절약하는 이메일 생성기"""
def __init__(self):
self.generator = EmailGenerator()
self._cache = {} # 간단한 인메모리 캐시
def _make_cache_key(self, request: EmailRequest) -> str:
"""요청 내용으로 캐시 키 생성"""
request_dict = request.dict()
request_str = json.dumps(request_dict, sort_keys=True, ensure_ascii=False)
return hashlib.md5(request_str.encode()).hexdigest()
def generate(self, request: EmailRequest) -> GeneratedEmail:
"""캐시 확인 후 없으면 생성"""
cache_key = self._make_cache_key(request)
if cache_key in self._cache:
print("💾 캐시에서 불러옴! (API 호출 절약)")
return self._cache[cache_key]
# 캐시 없으면 실제 생성
result = self.generator.generate(request)
self._cache[cache_key] = result
return result
CLI로만 쓰면 좀 불편하잖아?
Gradio 라이브러리 쓰면 코드 몇 줄로 웹 UI 뚝딱 만들 수 있음!
재능넷 같은 플랫폼에서 이런 AI 도구 만들어서 공유하면 진짜 인기 폭발할 듯 ㅎㅎ
# app.py - Gradio 웹 인터페이스
import gradio as gr
from email_generator.models import (
EmailRequest, SenderInfo, RecipientInfo,
EmailTone, EmailPurpose
)
from email_generator.generator import EmailGenerator
# 생성기 초기화 (앱 시작 시 한 번만)
generator = EmailGenerator()
def generate_email_ui(
sender_name, sender_company, sender_position,
recipient_name, recipient_company, recipient_position,
relationship, purpose, key_points_text, tone, max_length
):
"""Gradio UI에서 호출되는 이메일 생성 함수"""
# 핵심 내용 파싱 (줄바꿈으로 구분)
key_points = [p.strip() for p in key_points_text.split('\n') if p.strip()]
if not key_points:
return "❌ 핵심 내용을 최소 1개 이상 입력해주세요.", ""
try:
request = EmailRequest(
sender=SenderInfo(
name=sender_name,
company=sender_company or None,
position=sender_position or None
),
recipient=RecipientInfo(
name=recipient_name,
company=recipient_company or None,
position=recipient_position or None,
relationship=relationship
),
purpose=EmailPurpose(purpose),
key_points=key_points,
tone=EmailTone(tone),
max_length=int(max_length)
)
email = generator.generate(request)
subject_output = f"📧 {email.subject}"
body_output = email.body
return subject_output, body_output
except Exception as e:
return f"❌ 오류 발생: {str(e)}", ""
# Gradio 인터페이스 구성
with gr.Blocks(title="AI 이메일 생성기", theme=gr.themes.Soft()) as demo:
gr.Markdown("# 🤖 AI 개인 맞춤형 이메일 생성기")
gr.Markdown("LangChain + OpenAI GPT로 만든 스마트 이메일 생성기입니다.")
with gr.Row():
with gr.Column():
gr.Markdown("### 📤 발신자 정보")
sender_name = gr.Textbox(label="이름 *", placeholder="홍길동")
sender_company = gr.Textbox(label="회사명", placeholder="ABC 주식회사")
sender_position = gr.Textbox(label="직책", placeholder="마케팅팀장")
with gr.Column():
gr.Markdown("### 📥 수신자 정보")
recipient_name = gr.Textbox(label="이름 *", placeholder="김철수")
recipient_company = gr.Textbox(label="회사명", placeholder="XYZ 기업")
recipient_position = gr.Textbox(label="직책", placeholder="대표이사")
relationship = gr.Textbox(
label="관계",
placeholder="처음 연락 / 기존 거래처 / 상사 등",
value="처음 연락"
)
with gr.Row():
purpose = gr.Dropdown(
label="이메일 목적 *",
choices=[
("자기소개/첫 연락", "introduction"),
("후속 연락", "follow_up"),
("요청/부탁", "request"),
("제안", "proposal"),
("불만/항의", "complaint"),
("감사", "thank_you"),
("미팅 요청", "meeting_request")
],
value="proposal"
)
tone = gr.Dropdown(
label="이메일 톤 *",
choices=[
("격식체", "formal"),
("반격식체 (추천)", "semi_formal"),
("친근한", "friendly"),
("설득적", "persuasive"),
("사과/유감", "apologetic")
],
value="semi_formal"
)
key_points = gr.Textbox(
label="핵심 내용 (줄바꿈으로 구분) *",
placeholder="AI 솔루션 협력 제안\n다음 주 미팅 요청\n무료 데모 제공 가능",
lines=4
)
max_length = gr.Slider(
label="최대 글자 수",
minimum=100, maximum=800, value=300, step=50
)
generate_btn = gr.Button("✉️ 이메일 생성하기", variant="primary")
with gr.Row():
subject_output = gr.Textbox(label="📧 생성된 제목", interactive=False)
body_output = gr.Textbox(
label="📝 생성된 본문",
lines=10,
interactive=False
)
generate_btn.click(
fn=generate_email_ui,
inputs=[
sender_name, sender_company, sender_position,
recipient_name, recipient_company, recipient_position,
relationship, purpose, key_points, tone, max_length
],
outputs=[subject_output, body_output]
)
if __name__ == "__main__":
demo.launch(share=True) # share=True로 외부 공유 가능!
pip install gradio실행하면 로컬에서 http://localhost:7860 으로 접속 가능!
share=True 옵션 주면 임시 공개 URL도 생성됨 (72시간 유효)
이 이메일 생성기를 어떻게 더 발전시킬 수 있을지 아이디어 공유할게!
재능넷에서 이런 AI 개발 서비스 제공하면 진짜 수요 많을 것 같음 ㅎㅎ
과거에 보낸 이메일들을 분석해서 "나만의 글쓰기 스타일"을 학습하고 반영.
RAG(Retrieval-Augmented Generation) 기술 활용!
한국어 → 영어, 일본어, 중국어 이메일 자동 생성.
글로벌 비즈니스 커뮤니케이션에 활용!
생성된 이메일을 다시 AI가 평가해서 점수와 개선점 제안.
"이 이메일의 설득력: 8.5/10" 이런 식으로!
생성된 이메일을 바로 메일 클라이언트로 전송.
Python의 smtplib 또는 Gmail API 활용!
같은 목적으로 여러 버전 생성 후 어떤 게 더 효과적인지 추적.
영업 이메일 오픈율 최적화에 활용!
개발하다 보면 에러 만나는 건 당연한 거임 ㅋㅋㅋ
자주 나오는 에러들 미리 알아두면 시간 절약됨!
openai.AuthenticationError: Incorrect API key provided→ .env 파일에 API 키 제대로 입력했는지 확인. sk-proj-로 시작하는지 체크!
→
load_dotenv() 호출했는지 확인.
openai.RateLimitError: Rate limit reached→ API 호출 횟수 초과. 잠시 기다리거나 요청 간격 추가.
→
time.sleep(1) 추가하거나 max_retries 설정 활용.
pydantic.ValidationError: value is not a valid enumeration member→ EmailTone이나 EmailPurpose에 없는 값 입력 시 발생.
→ 허용된 값 목록 확인 후 올바른 값 입력.
ImportError: cannot import name 'LLMChain' from 'langchain'→ LangChain 0.2+ 버전에서 일부 임포트 경로 변경됨.
→
from langchain_openai import ChatOpenAI 처럼 새 경로 사용.
# 에러 핸들링 베스트 프랙티스
from openai import AuthenticationError, RateLimitError
from langchain_core.exceptions import OutputParserException
import time
def safe_generate(generator, request, max_retries=3):
"""안전한 이메일 생성 (에러 핸들링 포함)"""
for attempt in range(max_retries):
try:
return generator.generate(request)
except AuthenticationError:
print("❌ API 키 오류! .env 파일을 확인해주세요.")
raise # 재시도 불필요
except RateLimitError:
wait_time = (attempt + 1) * 2 # 2초, 4초, 6초 대기
print(f"⏳ Rate limit 초과. {wait_time}초 후 재시도...")
time.sleep(wait_time)
except OutputParserException as e:
print(f"⚠️ 출력 파싱 실패 (시도 {attempt+1}/{max_retries}): {e}")
if attempt == max_retries - 1:
raise
except Exception as e:
print(f"❌ 예상치 못한 오류: {e}")
raise
raise Exception("최대 재시도 횟수 초과")
이메일 생성기를 실제 서비스로 운영하려면 성능도 중요함!
특히 여러 사람이 동시에 쓰는 상황이라면 더더욱 ㅎㅎ
# 비동기 처리로 성능 향상
import asyncio
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser
class AsyncEmailGenerator:
"""비동기 이메일 생성기 - 여러 이메일 동시 생성 가능!"""
def __init__(self):
self.llm = ChatOpenAI(
model="gpt-4o-mini",
temperature=0.7,
api_key=os.getenv("OPENAI_API_KEY")
)
self.prompt = get_email_prompt_template()
self.chain = self.prompt | self.llm | StrOutputParser()
async def agenerate(self, chain_input: dict) -> str:
"""비동기 이메일 생성"""
# ainvoke()로 비동기 호출!
result = await self.chain.ainvoke(chain_input)
return result
async def generate_batch(self, requests: list[dict]) -> list[str]:
"""여러 이메일 동시 생성 (배치 처리)"""
tasks = [self.agenerate(req) for req in requests]
# asyncio.gather로 동시 실행!
results = await asyncio.gather(*tasks)
return list(results)
# 사용 예시
async def demo_async():
gen = AsyncEmailGenerator()
# 3개 이메일 동시 생성 (순차 처리 대비 ~3배 빠름!)
requests = [input1, input2, input3] # 각각의 입력 딕셔너리
results = await gen.generate_batch(requests)
for i, result in enumerate(results, 1):
print(f"이메일 {i}: {result[:50]}...")
# 실행
asyncio.run(demo_async())
비동기 방식으로 3개 이메일 생성: 약 2~3초 (동시 처리)
API 응답 기다리는 시간을 겹쳐서 처리하니까 훨씬 빠름!
와 여기까지 따라왔으면 진짜 대단한 거임 ㅎㅎ 👏
LangChain + OpenAI로 개인 맞춤형 이메일 생성기 만드는 전 과정을 다 커버했어!
오늘 배운 것들 정리하면:
이 프로젝트를 기반으로 더 발전시킬 수 있는 방향들:
- RAG 적용: 회사 내부 문서나 이전 이메일 데이터 학습
- Fine-tuning: 특정 도메인(법률, 의료 등)에 특화된 이메일 생성
- API 서버화: FastAPI로 REST API 만들어서 다른 서비스와 연동
- SaaS 서비스화: 구독 모델로 실제 비즈니스 런칭!
이메일 생성기 같은 실용적인 AI 도구를 만들어서 재능넷에서 서비스하면
개발 실력도 쌓고 수익도 낼 수 있는 일석이조 기회가 될 수 있어! 💪
LangChain 공식 문서 python.langchain.com/docs
OpenAI API 문서 platform.openai.com/docs
Pydantic 문서 docs.pydantic.dev
Gradio 문서 gradio.app/docs
LangChain GitHub github.com/langchain-ai/langchain
RAG (검색 증강 생성) 외부 데이터 연동
LangGraph 복잡한 에이전트 워크플로우
LangSmith LLM 앱 디버깅 & 모니터링
Vector DB Chroma, Pinecone, Weaviate
FastAPI AI 서비스 API 서버 구축
LangChain + OpenAI = 무한한 가능성!
이메일 생성기는 시작일 뿐이야.
이 기술로 챗봇, 문서 요약기, 코드 리뷰어 등 뭐든 만들 수 있음!
일단 만들어보고, 부수고, 다시 만들면서 배우는 게 최고야 💪
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.