IDEA-DESIGN

Running

App Files Files Community

IDEA-DESIGN / app.py

ginipick

Update app.py

2273a08 verified 2 months ago

raw

history blame

30.6 kB

	import os
	import streamlit as st
	import json
	import anthropic
	import requests
	import logging
	from gradio_client import Client
	import markdown
	import tempfile
	import base64
	from datetime import datetime
	import re
	from bs4 import BeautifulSoup # BeautifulSoup 추가

	# 로깅 설정
	logging.basicConfig(
	level=logging.INFO,
	format='%(asctime)s - %(levelname)s - %(message)s')

	# API 설정
	api_key = os.environ.get("API_KEY")
	client = anthropic.Anthropic(api_key=api_key)

	# 이미지 생성 API URL
	IMAGE_API_URL = "http://211.233.58.201:7896"

	# 최대 토큰 수 설정 (Claude-3 Sonnet의 최대 토큰 수)
	MAX_TOKENS = 7999

	# SerpHouse API Key 설정
	SERPHOUSE_API_KEY = os.environ.get("SERPHOUSE_API_KEY", "")

	def get_system_prompt():
	return """
	당신은 전문 블로그 작성 전문가입니다. 모든 블로그 글 작성 요청에 대해 다음의 8단계 프레임워크를 철저히 따르되, 자연스럽고 매력적인 글이 되도록 작성해야 합니다:

	독자 연결 단계 1.1. 공감대 형성을 위한 친근한 인사 1.2. 독자의 실제 고민을 반영한 도입 질문 1.3. 주제에 대한 즉각적 관심 유도

	문제 정의 단계 2.1. 독자의 페인포인트 구체화 2.2. 문제의 시급성과 영향도 분석 2.3. 해결 필요성에 대한 공감대 형성

	전문성 입증 단계 3.1. 객관적 데이터 기반 분석 3.2. 전문가 견해와 연구 결과 인용 3.3. 실제 사례를 통한 문제 구체화

	솔루션 제공 단계 4.1. 단계별 실천 가이드라인 제시 4.2. 즉시 적용 가능한 구체적 팁 4.3. 예상 장애물과 극복 방안 포함

	신뢰도 강화 단계 5.1. 실제 성공 사례 제시 5.2. 구체적 사용자 후기 인용 5.3. 객관적 데이터로 효과 입증

	행동 유도 단계 6.1. 명확한 첫 실천 단계 제시 6.2. 시급성을 강조한 행동 촉구 6.3. 실천 동기 부여 요소 포함

	진정성 강화 단계 7.1. 솔루션의 한계 투명하게 공개 7.2. 개인별 차이 존재 인정 7.3. 필요 조건과 주의사항 명시

	관계 지속 단계 8.1. 진정성 있는 감사 인사 8.2. 다음 컨텐츠 예고로 기대감 조성 8.3. 소통 채널 안내

	작성 시 준수사항 9.1. 글자 수: 1500-2000자 내외 9.2. 문단 길이: 3-4문장 이내 9.3. 시각적 구분: 소제목, 구분선, 번호 목록 활용 9.4. 톤앤매너: 친근하고 전문적인 대화체 9.5. 데이터: 모든 정보의 출처 명시 9.6. 가독성: 명확한 단락 구분과 강조점 사용

	이러한 프레임워크를 바탕으로, 요청받은 주제에 대해 체계적이고 매력적인 블로그 포스트를 작성하겠습니다.
	"""

	def test_image_api_connection():
	"""이미지 API 서버 연결 테스트"""
	try:
	client = Client(IMAGE_API_URL)
	return "이미지 API 연결 성공: 정상 작동 중"
	except Exception as e:
	logging.error(f"이미지 API 연결 테스트 실패: {e}")
	return f"이미지 API 연결 실패: {e}"

	def generate_image(prompt, width=768, height=768, guidance=3.5, inference_steps=30, seed=3):
	"""이미지 생성 함수"""
	if not prompt:
	return None, "오류: 프롬프트를 입력해주세요"

	try:
	client = Client(IMAGE_API_URL)
	result = client.predict(
	prompt=prompt,
	width=int(width),
	height=int(height),
	guidance=float(guidance),
	inference_steps=int(inference_steps),
	seed=int(seed),
	do_img2img=False,
	init_image=None,
	image2image_strength=0.8,
	resize_img=True,
	api_name="/generate_image"
	)
	logging.info(f"이미지 생성 성공: {result[1]}")
	return result[0], f"사용된 시드: {result[1]}"
	except Exception as e:
	logging.error(f"이미지 생성 실패: {str(e)}")
	return None, f"오류: {str(e)}"

	def extract_image_prompt(blog_content, blog_topic):
	"""블로그 내용에서 이미지 생성을 위한 프롬프트 추출"""
	image_prompt_system = f"""
	다음은 '{blog_topic}'에 관한 블로그 글입니다. 이 블로그 글의 내용을 기반으로 적절한 이미지를 생성하기 위한
	프롬프트를 작성해주세요. 프롬프트는 영어로 작성하고, 구체적인 시각적 요소를 담아야 합니다.
	프롬프트만 반환하세요(다른 설명 없이).

	예시 형식:
	"A professional photo of [subject], [specific details], [atmosphere], [lighting], [perspective], high quality, detailed"
	"""

	try:
	response = client.messages.create(
	model="claude-3-7-sonnet-20250219",
	max_tokens=150,
	system=image_prompt_system,
	messages=[{"role": "user", "content": blog_content}]
	)

	# 응답에서 프롬프트 추출
	image_prompt = response.content[0].text.strip()
	logging.info(f"생성된 이미지 프롬프트: {image_prompt}")
	return image_prompt
	except Exception as e:
	logging.error(f"이미지 프롬프트 생성 오류: {e}")
	return f"A professional photo related to {blog_topic}, detailed, high quality"

	# 마크다운을 HTML로 변환하는 함수
	def convert_md_to_html(md_text, title="Ginigen Blog"):
	html_content = markdown.markdown(md_text)
	html_doc = f"""
	<!DOCTYPE html>
	<html>
	<head>
	<title>{title}</title>
	<meta charset="utf-8">
	<style>
	body {{ font-family: Arial, sans-serif; line-height: 1.6; max-width: 800px; margin: 0 auto; padding: 20px; }}
	h1 {{ color: #2c3e50; font-size: 2.5em; margin-bottom: 20px; }}
	h2 {{ color: #3498db; margin-top: 25px; font-size: 1.8em; }}
	h3 {{ color: #2980b9; font-size: 1.5em; }}
	p {{ margin-bottom: 15px; font-size: 1.1em; }}
	blockquote {{ background: #f9f9f9; border-left: 10px solid #ccc; margin: 1.5em 10px; padding: 1em 10px; }}
	ul, ol {{ margin-bottom: 15px; }}
	li {{ margin-bottom: 5px; }}
	hr {{ border: 0; height: 1px; background: #ddd; margin: 20px 0; }}
	img {{ max-width: 100%; height: auto; display: block; margin: 20px auto; }}
	</style>
	</head>
	<body>
	{html_content}
	</body>
	</html>
	"""
	return html_doc

	# 웹 검색 키워드 추출 함수
	def extract_keywords(text: str, top_k: int = 5) -> str:
	"""
	1) 한글(가-힣), 영어(a-zA-Z), 숫자(0-9), 공백만 남김
	2) 공백 기준 토큰 분리
	3) 최대 top_k개만
	"""
	text = re.sub(r"[^a-zA-Z0-9가-힣\s]", "", text)
	tokens = text.split()
	key_tokens = tokens[:top_k]
	return " ".join(key_tokens)

	# Mock 검색 결과 생성 함수
	def generate_mock_search_results(query):
	"""API 연결이 안될 때 사용할 가상 검색 결과 생성"""
	current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
	mock_results = [
	{
	"title": f"{query}에 관한 최신 정보",
	"link": "https://example.com/article1",
	"snippet": f"{query}에 관한 가상 검색 결과입니다. 이 결과는 API 연결 문제로 인해 생성된 가상 데이터입니다. 실제 검색 결과가 아님을 참고하세요. 생성 시간: {current_time}",
	"displayed_link": "example.com/article1"
	},
	{
	"title": f"{query} 관련 연구 동향",
	"link": "https://example.org/research",
	"snippet": "이것은 API 연결 문제로 인한 가상 검색 결과입니다. 실제 검색 결과를 보여드리지 못해 죄송합니다. 대신 AI의 기존 지식을 활용하여 답변드리겠습니다.",
	"displayed_link": "example.org/research"
	},
	{
	"title": f"{query}의 역사적 배경",
	"link": "https://example.net/history",
	"snippet": "이 가상 검색 결과는 API 연결 문제로 인해 생성되었습니다. 참고용으로만 사용해주세요.",
	"displayed_link": "example.net/history"
	}
	]

	summary_lines = []
	for idx, item in enumerate(mock_results, start=1):
	title = item.get("title", "No title")
	link = item.get("link", "#")
	snippet = item.get("snippet", "No description")
	displayed_link = item.get("displayed_link", link)

	summary_lines.append(
	f"### Result {idx}: {title}\n\n"
	f"{snippet}\n\n"
	f"출처: [{displayed_link}]({link})\n\n"
	f"---\n"
	)

	notice = """
	# 가상 검색 결과 (API 연결 문제로 인해 생성됨)
	아래는 API 연결 문제로 인해 생성된 가상 검색 결과입니다. 실제 검색 결과가 아님을 참고하세요.
	대신 AI의 기존 지식을 활용하여 최대한 정확한 답변을 드리겠습니다.
	"""

	return notice + "\n".join(summary_lines)

	# Google 검색 함수 (SerpAPI 대신 직접 검색)
	# Google 검색 함수 (BeautifulSoup을 사용하여 결과 파싱)
	def do_google_search(query, num_results=5):
	try:
	# 다양한 User-Agent 사용 (Google 차단 방지)
	headers = {
	'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
	'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,/;q=0.8',
	'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
	'Accept-Encoding': 'gzip, deflate, br',
	'Referer': 'https://www.google.com/',
	'DNT': '1',
	'Connection': 'keep-alive',
	'Upgrade-Insecure-Requests': '1',
	'Cache-Control': 'max-age=0',
	}

	# 검색 URL (일부 파라미터 추가)
	search_url = f"https://www.google.com/search?q={query}&num={num_results}&hl=ko&gl=kr"
	logging.info(f"구글 검색 URL: {search_url}")

	# 요청 보내기 (짧은 타임아웃 설정)
	response = requests.get(search_url, headers=headers, timeout=10)

	# 응답이 성공적인지 확인
	if response.status_code != 200:
	logging.error(f"Google 검색 응답 상태 코드: {response.status_code}")
	return generate_mock_search_results(query)

	# BeautifulSoup으로 HTML 파싱
	soup = BeautifulSoup(response.text, 'html.parser')

	# 검색 결과 추출
	organic_results = []

	# 검색 결과 컨테이너 찾기 (Google의 HTML 구조에 따라 변경될 수 있음)
	result_containers = soup.select('div.g')

	if not result_containers:
	logging.warning("Google 검색 결과 컨테이너를 찾을 수 없습니다. 대체 선택자를 시도합니다.")
	# 대체 선택자 시도
	result_containers = soup.select('div[data-hveid]')

	counter = 0
	for container in result_containers:
	if counter >= num_results:
	break

	# 제목 추출
	title_element = container.select_one('h3')
	if not title_element:
	continue

	title = title_element.get_text()

	# 링크 추출
	link_element = container.select_one('a')
	if not link_element:
	continue

	link = link_element.get('href', '')
	if link.startswith('/url?'):
	# Google의 리다이렉트 URL에서 실제 URL 추출
	link = link.split('q=')[1].split('&')[0] if 'q=' in link else link
	elif not link.startswith('http'):
	continue

	# 스니펫 추출
	snippet_element = container.select_one('div.VwiC3b') or container.select_one('span.aCOpRe')
	snippet = snippet_element.get_text() if snippet_element else "설명 없음"

	# 표시 링크 추출
	displayed_link_element = container.select_one('cite')
	displayed_link = displayed_link_element.get_text() if displayed_link_element else link

	organic_results.append({
	"title": title,
	"link": link,
	"snippet": snippet,
	"displayed_link": displayed_link
	})
	counter += 1

	if not organic_results:
	logging.warning("검색 결과를 파싱할 수 없습니다. 선택자가 변경되었을 수 있습니다.")
	return generate_mock_search_results(query)

	# 검색 결과 마크다운 형식으로 변환
	summary_lines = []
	for idx, item in enumerate(organic_results, start=1):
	title = item.get("title", "No title")
	link = item.get("link", "#")
	snippet = item.get("snippet", "No description")
	displayed_link = item.get("displayed_link", link)

	summary_lines.append(
	f"### Result {idx}: {title}\n\n"
	f"{snippet}\n\n"
	f"출처: [{displayed_link}]({link})\n\n"
	f"---\n"
	)

	# 모델에게 명확한 지침 추가
	instructions = """
	# 웹 검색 결과
	아래는 검색 결과입니다. 질문에 답변할 때 이 정보를 활용하세요:
	1. 각 결과의 제목, 내용, 출처 링크를 참고하세요
	2. 답변에 관련 정보의 출처를 명시적으로 인용하세요 (예: "X 출처에 따르면...")
	3. 응답에 실제 출처 링크를 포함하세요
	4. 여러 출처의 정보를 종합하여 답변하세요
	"""

	search_results = instructions + "\n".join(summary_lines)
	logging.info(f"Google 검색 결과 {len(organic_results)}개 파싱 완료")
	return search_results

	except Exception as e:
	logging.error(f"Google 검색 실패: {e}")
	return generate_mock_search_results(query)

	# 웹 검색 함수
	def do_web_search(query: str) -> str:
	"""
	웹 검색을 수행하는 함수 - SerpHouse API 또는 직접 구글 검색
	"""
	try:
	# API 키가 없거나 'mock'인 경우
	if not SERPHOUSE_API_KEY or "mock" in SERPHOUSE_API_KEY.lower():
	logging.warning("API 키가 없거나 Mock 모드입니다. 가상 검색 결과를 반환합니다.")
	return generate_mock_search_results(query)

	# SerpHouse API 사용
	url = "https://api.serphouse.com/serp/live"
	params = {
	"q": query,
	"domain": "google.com",
	"serp_type": "web",
	"device": "desktop",
	"lang": "ko", # 한국어 결과
	"num": "5" # 결과 수 줄임
	}

	headers = {
	"Authorization": f"Bearer {SERPHOUSE_API_KEY}"
	}

	logging.info(f"SerpHouse API 호출 중... 검색어: {query}")

	# 짧은 타임아웃으로 요청 시도
	response = requests.get(url, headers=headers, params=params, timeout=15)
	response.raise_for_status()

	logging.info(f"SerpHouse API 응답 상태 코드: {response.status_code}")
	data = response.json()

	# 다양한 응답 구조 처리
	results = data.get("results", {})
	organic = None

	# 가능한 응답 구조 1
	if isinstance(results, dict) and "organic" in results:
	organic = results["organic"]
	# 가능한 응답 구조 2
	elif isinstance(results, dict) and "results" in results:
	if isinstance(results["results"], dict) and "organic" in results["results"]:
	organic = results["results"]["organic"]
	# 가능한 응답 구조 3
	elif "organic" in data:
	organic = data["organic"]

	if not organic:
	logging.warning("응답에서 organic 결과를 찾을 수 없습니다. 구글 직접 검색으로 전환합니다.")
	return do_google_search(query)

	# 결과 수 제한 및 컨텍스트 길이 최적화
	max_results = min(5, len(organic))
	limited_organic = organic[:max_results]

	# 결과 형식 개선
	summary_lines = []
	for idx, item in enumerate(limited_organic, start=1):
	title = item.get("title", "No title")
	link = item.get("link", "#")
	snippet = item.get("snippet", "No description")
	displayed_link = item.get("displayed_link", link)

	summary_lines.append(
	f"### Result {idx}: {title}\n\n"
	f"{snippet}\n\n"
	f"출처: [{displayed_link}]({link})\n\n"
	f"---\n"
	)

	# 모델에게 명확한 지침 추가
	instructions = """
	# 웹 검색 결과
	아래는 검색 결과입니다. 질문에 답변할 때 이 정보를 활용하세요:
	1. 각 결과의 제목, 내용, 출처 링크를 참고하세요
	2. 답변에 관련 정보의 출처를 명시적으로 인용하세요 (예: "X 출처에 따르면...")
	3. 응답에 실제 출처 링크를 포함하세요
	4. 여러 출처의 정보를 종합하여 답변하세요
	"""

	search_results = instructions + "\n".join(summary_lines)
	logging.info(f"검색 결과 {len(limited_organic)}개 처리 완료")
	return search_results

	except requests.exceptions.Timeout:
	logging.error("Web search timed out, 직접 구글 검색으로 전환합니다.")
	return do_google_search(query)
	except Exception as e:
	logging.error(f"Web search failed: {e}, 직접 구글 검색으로 전환합니다.")
	return do_google_search(query)

	def chatbot_interface():
	st.title("Ginigen Blog")

	# 모델 고정 설정
	if "ai_model" not in st.session_state:
	st.session_state["ai_model"] = "claude-3-7-sonnet-20250219"

	# 세션 상태 초기화
	if "messages" not in st.session_state:
	st.session_state.messages = []

	# 자동 저장 기능
	if "auto_save" not in st.session_state:
	st.session_state.auto_save = True

	# 이미지 생성 토글
	if "generate_image" not in st.session_state:
	st.session_state.generate_image = False

	# 웹 검색 토글
	if "use_web_search" not in st.session_state:
	st.session_state.use_web_search = False

	# 이미지 API 상태
	if "image_api_status" not in st.session_state:
	st.session_state.image_api_status = test_image_api_connection()

	# 대화 기록 관리 (사이드바)
	st.sidebar.title("대화 기록 관리")

	# 자동 저장 토글
	st.session_state.auto_save = st.sidebar.toggle("자동 저장", value=st.session_state.auto_save)

	# 이미지 생성 토글
	st.session_state.generate_image = st.sidebar.toggle("블로그 글 작성 후 이미지 자동 생성", value=st.session_state.generate_image)

	# 웹 검색 토글
	st.session_state.use_web_search = st.sidebar.toggle("주제 웹 검색 및 분석", value=st.session_state.use_web_search)

	# 이미지 API 상태 표시
	st.sidebar.text(st.session_state.image_api_status)

	# 이미지 생성 설정 (토글이 켜져 있을 때만 표시)
	if st.session_state.generate_image:
	st.sidebar.subheader("이미지 생성 설정")
	width = st.sidebar.slider("너비", 256, 1024, 768, 64)
	height = st.sidebar.slider("높이", 256, 1024, 768, 64)
	guidance = st.sidebar.slider("가이던스 스케일", 1.0, 20.0, 3.5, 0.1)
	inference_steps = st.sidebar.slider("인퍼런스 스텝", 1, 50, 30, 1)
	seed = st.sidebar.number_input("시드", value=3, min_value=0, step=1)
	else:
	# 기본값 설정
	width, height, guidance, inference_steps, seed = 768, 768, 3.5, 30, 3

	# 블로그 내용 다운로드 섹션
	st.sidebar.title("블로그 다운로드")

	# 최신 블로그 내용 가져오기
	latest_blog = None
	latest_blog_title = "블로그 글"

	if len(st.session_state.messages) > 0:
	# 가장 최근 assistant 메시지 찾기
	for msg in reversed(st.session_state.messages):
	if msg["role"] == "assistant" and msg["content"].strip():
	latest_blog = msg["content"]

	# 타이틀 추출 시도 (첫 번째 제목 태그 사용)
	title_match = re.search(r'# (.*?)(\n\|$)', latest_blog)
	if title_match:
	latest_blog_title = title_match.group(1).strip()
	# 사용자 입력을 타이틀로 사용
	elif len(st.session_state.messages) >= 2:
	for i in range(len(st.session_state.messages)-1, -1, -1):
	if st.session_state.messages[i]["role"] == "user":
	latest_blog_title = st.session_state.messages[i]["content"][:30].strip()
	if len(st.session_state.messages[i]["content"]) > 30:
	latest_blog_title += "..."
	break
	break

	# 다운로드 버튼 그룹
	if latest_blog:
	st.sidebar.subheader("최근 블로그 다운로드")

	col1, col2 = st.sidebar.columns(2)

	# 마크다운으로 다운로드
	with col1:
	st.download_button(
	label="마크다운",
	data=latest_blog,
	file_name=f"{latest_blog_title}.md",
	mime="text/markdown"
	)

	# HTML로 다운로드
	with col2:
	html_content = convert_md_to_html(latest_blog, latest_blog_title)
	st.download_button(
	label="HTML",
	data=html_content,
	file_name=f"{latest_blog_title}.html",
	mime="text/html"
	)

	# 대화 기록 불러오기
	uploaded_file = st.sidebar.file_uploader("대화 기록 불러오기", type=['json'])
	if uploaded_file is not None:
	try:
	content = uploaded_file.getvalue().decode()
	if content.strip():
	st.session_state.messages = json.loads(content)
	st.sidebar.success("대화 기록을 성공적으로 불러왔습니다!")
	else:
	st.sidebar.warning("업로드된 파일이 비어 있습니다.")
	except json.JSONDecodeError:
	st.sidebar.error("올바른 JSON 형식의 파일이 아닙니다.")
	except Exception as e:
	st.sidebar.error(f"파일 처리 중 오류가 발생했습니다: {str(e)}")

	# 대화 기록 초기화 버튼
	if st.sidebar.button("대화 기록 초기화"):
	st.session_state.messages = []
	st.sidebar.success("대화 기록이 초기화되었습니다.")

	# 메시지 표시
	for message in st.session_state.messages:
	with st.chat_message(message["role"]):
	st.markdown(message["content"])
	# 이미지가 있는 경우 표시
	if "image" in message:
	st.image(message["image"], caption=message.get("image_caption", "생성된 이미지"))

	# 사용자 입력
	if prompt := st.chat_input("무엇을 도와드릴까요?"):
	st.session_state.messages.append({"role": "user", "content": prompt})
	with st.chat_message("user"):
	st.markdown(prompt)

	# AI 응답 생성
	with st.chat_message("assistant"):
	message_placeholder = st.empty()
	full_response = ""

	# 웹 검색 수행 (웹 검색 옵션이 켜져 있을 경우)
	system_prompt = get_system_prompt()
	if st.session_state.use_web_search:
	with st.spinner("웹에서 관련 정보를 검색 중..."):
	try:
	search_query = extract_keywords(prompt, top_k=5)
	st.info(f"검색어: {search_query}")

	# 두 가지 방법 모두 시도 (SerpHouse API와 직접 검색)
	search_results = do_web_search(search_query)

	if "가상 검색 결과" in search_results:
	st.warning("실제 검색 결과를 가져올 수 없어 기존 지식을 활용합니다.")
	else:
	st.success(f"검색 완료: '{search_query}'에 대한 정보를 수집했습니다.")

	# 시스템 프롬프트에 검색 결과 추가
	system_prompt += f"\n\n검색 결과:\n{search_results}\n"
	except Exception as e:
	st.error(f"웹 검색 중 오류가 발생했습니다: {str(e)}")
	logging.error(f"웹 검색 오류: {str(e)}")
	system_prompt += "\n\n웹 검색이 실패했습니다. 기존 지식을 바탕으로 답변하세요."

	# API 호출
	with client.messages.stream(
	max_tokens=MAX_TOKENS,
	system=system_prompt,
	messages=[{"role": m["role"], "content": m["content"]} for m in st.session_state.messages],
	model=st.session_state["ai_model"]
	) as stream:
	for text in stream.text_stream:
	full_response += str(text) if text is not None else ""
	message_placeholder.markdown(full_response + "▌")

	message_placeholder.markdown(full_response)

	# 이미지 생성 옵션이 켜져 있는 경우
	if st.session_state.generate_image:
	with st.spinner("블로그에 맞는 이미지 생성 중..."):
	# 이미지 프롬프트 생성
	image_prompt = extract_image_prompt(full_response, prompt)

	# 이미지 생성
	image, image_caption = generate_image(
	image_prompt,
	width=width,
	height=height,
	guidance=guidance,
	inference_steps=inference_steps,
	seed=seed
	)

	if image:
	st.image(image, caption=image_caption)
	# 이미지 정보를 응답에 포함
	st.session_state.messages.append({
	"role": "assistant",
	"content": full_response,
	"image": image,
	"image_caption": image_caption
	})
	else:
	st.error(f"이미지 생성 실패: {image_caption}")
	st.session_state.messages.append({
	"role": "assistant",
	"content": full_response
	})
	else:
	# 이미지 생성 없이 응답만 저장
	st.session_state.messages.append({
	"role": "assistant",
	"content": full_response
	})

	# 블로그 다운로드 버튼 표시 (응답 바로 아래에)
	st.subheader("이 블로그 다운로드:")
	col1, col2 = st.columns(2)

	with col1:
	st.download_button(
	label="마크다운으로 저장",
	data=full_response,
	file_name=f"{prompt[:30]}.md",
	mime="text/markdown"
	)

	with col2:
	html_content = convert_md_to_html(full_response, prompt[:30])
	st.download_button(
	label="HTML로 저장",
	data=html_content,
	file_name=f"{prompt[:30]}.html",
	mime="text/html"
	)

	# 자동 저장 기능
	if st.session_state.auto_save:
	try:
	# 이미지 정보는 저장하지 않음 (JSON에는 바이너리 데이터를 직접 저장할 수 없음)
	save_messages = []
	for msg in st.session_state.messages:
	save_msg = {"role": msg["role"], "content": msg["content"]}
	save_messages.append(save_msg)

	# 현재 시간을 포함한 파일명 생성
	current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
	filename = f'chat_history_auto_save_{current_time}.json'

	with open(filename, 'w', encoding='utf-8') as f:
	json.dump(save_messages, f, ensure_ascii=False, indent=4)
	except Exception as e:
	st.sidebar.error(f"자동 저장 중 오류 발생: {str(e)}")

	# 대화 기록 다운로드
	if st.sidebar.button("대화 기록 다운로드"):
	# 이미지 정보는 저장하지 않음
	save_messages = []
	for msg in st.session_state.messages:
	save_msg = {"role": msg["role"], "content": msg["content"]}
	save_messages.append(save_msg)

	json_history = json.dumps(save_messages, indent=4, ensure_ascii=False)
	st.sidebar.download_button(
	label="대화 기록 저장하기",
	data=json_history,
	file_name="chat_history.json",
	mime="application/json"
	)

	def main():
	chatbot_interface()

	if __name__ == "__main__":
	# requirements.txt 파일 생성
	with open("requirements.txt", "w") as f:
	f.write("streamlit>=1.31.0\n")
	f.write("anthropic>=0.18.1\n")
	f.write("gradio-client>=1.8.0\n")
	f.write("requests>=2.32.3\n")
	f.write("markdown>=3.5.1\n")
	f.write("pillow>=10.1.0\n")

	main()