์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿค– ์ฑ—๋ด‡ ๊ธฐ๋ณธ ์†Œ์Šค์ฝ”๋“œ ์™„์ „ ์ •๋ณต: AI ๋Œ€ํ™” ์—”์ง„ ๋งŒ๋“ค๊ธฐ

๐Ÿค– ์ฑ—๋ด‡ ๊ธฐ๋ณธ ์†Œ์Šค์ฝ”๋“œ ์™„์ „ ์ •๋ณต: AI ๋Œ€ํ™” ์—”์ง„ ๋งŒ๋“ค๊ธฐ

์นœ๊ตฌ์ฒ˜๋Ÿผ ๋Œ€ํ™”ํ•˜๋Š” ๋˜‘๋˜‘ํ•œ ์ฑ—๋ด‡, ์ง์ ‘ ๋งŒ๋“ค์–ด๋ณด์ž!

๐Ÿ’ฌ ์š”์ฆ˜ ์›น์‚ฌ์ดํŠธ๋‚˜ ์•ฑ์— ๋“ค์–ด๊ฐ€๋ฉด ์˜ค๋ฅธ์ชฝ ํ•˜๋‹จ์— "๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”?"๋ผ๊ณ  ๋ง ๊ฑฐ๋Š” ์ž‘์€ ์ฐฝ, ํ•œ ๋ฒˆ์ฏค ๋ดค์„ ๊ฑฐ์•ผ! ๋ฐ”๋กœ ์ฑ—๋ด‡์ด์ง€. ๊ณ ๊ฐ ๋ฌธ์˜๋ฅผ ๋ฐ›๊ฑฐ๋‚˜, ์ƒํ’ˆ์„ ์ถ”์ฒœํ•˜๊ฑฐ๋‚˜, ์‹ฌ์ง€์–ด ๋†๋‹ด๊นŒ์ง€ ์ฃผ๊ณ ๋ฐ›๋Š” ์ด ๋˜‘๋˜‘ํ•œ ์นœ๊ตฌ๋“ค์€ ์–ด๋–ป๊ฒŒ ๋งŒ๋“ค์–ด์งˆ๊นŒ? ๐Ÿค”

์˜ค๋Š˜์€ ์ฑ—๋ด‡์˜ ๊ธฐ๋ณธ ์†Œ์Šค์ฝ”๋“œ๋ถ€ํ„ฐ AI ๋Œ€ํ™” ์—”์ง„์˜ ํ•ต์‹ฌ ์›๋ฆฌ๊นŒ์ง€, ์นœ๊ตฌ์—๊ฒŒ ์„ค๋ช…ํ•˜๋“ฏ ์‰ฝ๊ณ  ์žฌ๋ฏธ์žˆ๊ฒŒ ํ’€์–ด๋ณผ๊ฒŒ. ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด ์ฒ˜์Œ์ด๋ผ๋„ ๊ฑฑ์ • ๋งˆ! ์ฐจ๊ทผ์ฐจ๊ทผ ๋”ฐ๋ผ์˜ค๋ฉด ๋„ˆ๋„ ๋‚˜๋งŒ์˜ ์ฑ—๋ด‡์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ๐Ÿš€

์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”? ์ฑ—๋ด‡ ๋งŒ๋“œ๋Š” ๋ฐฉ๋ฒ• ์•Œ๋ ค์ฃผ์„ธ์š”! ๋„ค! ๊ธฐ๋ณธ ์†Œ์Šค์ฝ”๋“œ๋ถ€ํ„ฐ AI ์—”์ง„ ๊ตฌ์ถ•๊นŒ์ง€ ์ฐจ๊ทผ์ฐจ๊ทผ ์•Œ๋ ค๋“œ๋ฆด๊ฒŒ์š” ๐Ÿ˜Š

๐ŸŽฏ ์ฑ—๋ด‡์ด๋ž€ ๋ฌด์—‡์ธ๊ฐ€?

์ฑ—๋ด‡(Chatbot)์€ 'Chat(์ฑ„ํŒ…)'๊ณผ 'Bot(๋กœ๋ด‡)'์˜ ํ•ฉ์„ฑ์–ด์•ผ. ์‚ฌ๋žŒ์ฒ˜๋Ÿผ ๋Œ€ํ™”ํ•  ์ˆ˜ ์žˆ๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งํ•˜์ง€. ๋‹จ์ˆœํžˆ ์ •ํ•ด์ง„ ๋‹ต๋ณ€๋งŒ ํ•˜๋Š” ์ดˆ๋ณด ์ฑ—๋ด‡๋ถ€ํ„ฐ, AI๋ฅผ ํ™œ์šฉํ•ด์„œ ๋งฅ๋ฝ์„ ์ดํ•ดํ•˜๊ณ  ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ๋Œ€ํ™”ํ•˜๋Š” ๊ณ ๊ธ‰ ์ฑ—๋ด‡๊นŒ์ง€ ๋‹ค์–‘ํ•ด. ๐ŸŽญ

๐Ÿ“Œ ์ฑ—๋ด‡์˜ 3๊ฐ€์ง€ ๋ ˆ๋ฒจ

Level 1: ๊ทœ์น™ ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡
๋ฏธ๋ฆฌ ์ •ํ•ด์ง„ ์‹œ๋‚˜๋ฆฌ์˜ค๋Œ€๋กœ๋งŒ ์›€์ง์—ฌ. "์•ˆ๋…•"์ด๋ผ๊ณ  ํ•˜๋ฉด "์•ˆ๋…•ํ•˜์„ธ์š”!"๋ผ๊ณ  ๋‹ตํ•˜๋Š” ์‹์ด์ง€. ๊ฐ„๋‹จํ•˜์ง€๋งŒ ์œตํ†ต์„ฑ์ด ์—†์–ด.

Level 2: ํ‚ค์›Œ๋“œ ์ธ์‹ ์ฑ—๋ด‡
์‚ฌ์šฉ์ž ์ž…๋ ฅ์—์„œ ํ•ต์‹ฌ ํ‚ค์›Œ๋“œ๋ฅผ ์ฐพ์•„๋‚ด์„œ ๋ฐ˜์‘ํ•ด. "๋ฐฐ์†ก"์ด๋ผ๋Š” ๋‹จ์–ด๋ฅผ ๋ฐœ๊ฒฌํ•˜๋ฉด ๋ฐฐ์†ก ๊ด€๋ จ ๋‹ต๋ณ€์„ ํ•˜๋Š” ๊ฑฐ์•ผ. ์กฐ๊ธˆ ๋” ๋˜‘๋˜‘ํ•˜์ง€?

Level 3: AI ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡
์ž์—ฐ์–ด ์ฒ˜๋ฆฌ(NLP)์™€ ๋จธ์‹ ๋Ÿฌ๋‹์„ ํ™œ์šฉํ•ด์„œ ๋ฌธ๋งฅ์„ ์ดํ•ดํ•˜๊ณ  ํ•™์Šตํ•ด. ๋Œ€ํ™”ํ• ์ˆ˜๋ก ๋˜‘๋˜‘ํ•ด์ง€๋Š” ์ง„์งœ AI ์นœ๊ตฌ! ๐Ÿง 

๐Ÿ’ก ์žฌ๋Šฅ๋„ท TIP ์ฑ—๋ด‡ ๊ฐœ๋ฐœ์ด ์ฒ˜์Œ์ด๋ผ๋ฉด ์žฌ๋Šฅ๋„ท์—์„œ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ ์ „๋ฌธ๊ฐ€์˜ ๋„์›€์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ฅผ ๋ฐฐ์šฐ๊ณ  ๋‚˜์„œ ์ง์ ‘ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•ํ•˜๋ฉด ํ›จ์”ฌ ๋น ๋ฅด๊ฒŒ ์„ฑ์žฅํ•  ์ˆ˜ ์žˆ์–ด!

๐Ÿ› ๏ธ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ ํ™˜๊ฒฝ ์ค€๋น„ํ•˜๊ธฐ

๋ณธ๊ฒฉ์ ์œผ๋กœ ์ฝ”๋”ฉ์— ๋“ค์–ด๊ฐ€๊ธฐ ์ „์—, ํ•„์š”ํ•œ ๋„๊ตฌ๋“ค์„ ๋จผ์ € ์ฑ™๊ฒจ๋ณด์ž! ์š”๋ฆฌํ•˜๊ธฐ ์ „์— ์žฌ๋ฃŒ ์ค€๋น„ํ•˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ง์ด์•ผ. ๐Ÿ‘จโ€๐Ÿณ

1๋‹จ๊ณ„: ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด ์„ ํƒ ๐ŸŽจ

์ฑ—๋ด‡์€ ๋‹ค์–‘ํ•œ ์–ธ์–ด๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ๊ฐ€์žฅ ์ธ๊ธฐ ์žˆ๋Š” ๊ฑด:

โ€ข Python: ์ดˆ๋ณด์ž ์นœํ™”์ ์ด๊ณ  AI ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ํ’๋ถ€ํ•ด
โ€ข JavaScript: ์›น ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡์— ์ตœ์ ํ™”
โ€ข Java: ๋Œ€๊ทœ๋ชจ ์—”ํ„ฐํ”„๋ผ์ด์ฆˆ ํ™˜๊ฒฝ์— ์ ํ•ฉ
โ€ข Node.js: ์‹ค์‹œ๊ฐ„ ํ†ต์‹ ์— ๊ฐ•๋ ฅํ•จ

2๋‹จ๊ณ„: ๊ฐœ๋ฐœ ๋„๊ตฌ ์„ค์น˜ ๐Ÿ’ป

โ€ข ์ฝ”๋“œ ์—๋””ํ„ฐ: VS Code, PyCharm, Sublime Text ๋“ฑ
โ€ข ํŒจํ‚ค์ง€ ๊ด€๋ฆฌ์ž: pip(Python), npm(JavaScript)
โ€ข ๋ฒ„์ „ ๊ด€๋ฆฌ: Git (๋‚˜์ค‘์— ํ˜‘์—…ํ•  ๋•Œ ํ•„์ˆ˜!)

3๋‹จ๊ณ„: ํ•„์ˆ˜ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์„ค์น˜ ๐Ÿ“ฆ

Python ๊ธฐ์ค€์œผ๋กœ ์„ค๋ช…ํ• ๊ฒŒ:

# ๊ธฐ๋ณธ ์›น ํ”„๋ ˆ์ž„์›Œํฌ
pip install flask

# ์ž์—ฐ์–ด ์ฒ˜๋ฆฌ
pip install nltk
pip install spacy

# ๋จธ์‹ ๋Ÿฌ๋‹
pip install tensorflow
pip install scikit-learn

# ์ฑ—๋ด‡ ํ”„๋ ˆ์ž„์›Œํฌ
pip install chatterbot
pip install rasa

โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ๋ฒ„์ „ ํ˜ธํ™˜์„ฑ์„ ๊ผญ ํ™•์ธํ•ด! ํŠนํžˆ TensorFlow์™€ Python ๋ฒ„์ „ ๊ฐ„์˜ ๊ถํ•ฉ์ด ์ค‘์š”ํ•ด. ๊ณต์‹ ๋ฌธ์„œ๋ฅผ ์ฐธ๊ณ ํ•˜๋Š” ์Šต๊ด€์„ ๋“ค์ด์ž.

๐Ÿš€ ์ฒซ ๋ฒˆ์งธ ์ฑ—๋ด‡ ๋งŒ๋“ค๊ธฐ: ๊ทœ์น™ ๊ธฐ๋ฐ˜ ๋ฒ„์ „

์ž, ์ด์ œ ์ง„์งœ ์ฝ”๋”ฉ์„ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ? ๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ๊ทœ์น™ ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡๋ถ€ํ„ฐ ๋งŒ๋“ค์–ด๋ณด์ž! ๐ŸŽ‰

๐Ÿ“ Python์œผ๋กœ ๋งŒ๋“œ๋Š” ์ดˆ๊ฐ„๋‹จ ์ฑ—๋ด‡

# simple_chatbot.py
# ๊ธฐ๋ณธ ์ฑ—๋ด‡ ํด๋ž˜์Šค ์ •์˜

class SimpleChatbot:
    def __init__(self):
        # ์‘๋‹ต ๊ทœ์น™ ๋”•์…”๋„ˆ๋ฆฌ
        self.responses = {
            "์•ˆ๋…•": "์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”? ๐Ÿ˜Š",
            "์ด๋ฆ„": "์ €๋Š” ํŒŒ์ด๋ด‡์ด์—์š”! ๋‹น์‹ ์˜ ์ด๋ฆ„์€ ๋ฌด์—‡์ธ๊ฐ€์š”?",
            "๋‚ ์”จ": "์ฃ„์†กํ•ด์š”, ์•„์ง ๋‚ ์”จ ์ •๋ณด๋Š” ์ œ๊ณตํ•˜์ง€ ๋ชปํ•ด์š”. ๐ŸŒค๏ธ",
            "๊ณ ๋งˆ์›Œ": "์ฒœ๋งŒ์—์š”! ๋˜ ๊ถ๊ธˆํ•œ ๊ฒŒ ์žˆ์œผ๋ฉด ๋ฌผ์–ด๋ณด์„ธ์š”!",
            "์•ˆ๋…•ํžˆ": "์ข‹์€ ํ•˜๋ฃจ ๋˜์„ธ์š”! ๋‹ค์Œ์— ๋˜ ๋งŒ๋‚˜์š”! ๐Ÿ‘‹"
        }
        
    def get_response(self, user_input):
        # ์‚ฌ์šฉ์ž ์ž…๋ ฅ์„ ์†Œ๋ฌธ์ž๋กœ ๋ณ€ํ™˜
        user_input = user_input.lower().strip()
        
        # ํ‚ค์›Œ๋“œ ๋งค์นญ
        for keyword, response in self.responses.items():
            if keyword in user_input:
                return response
        
        # ๋งค์นญ๋˜๋Š” ๊ฒŒ ์—†์œผ๋ฉด ๊ธฐ๋ณธ ์‘๋‹ต
        return "์Œ... ์ž˜ ์ดํ•ดํ•˜์ง€ ๋ชปํ–ˆ์–ด์š”. ๋‹ค์‹œ ๋ง์”€ํ•ด์ฃผ์‹œ๊ฒ ์–ด์š”? ๐Ÿค”"
    
    def start(self):
        print("์ฑ—๋ด‡: ์•ˆ๋…•ํ•˜์„ธ์š”! ๋Œ€ํ™”๋ฅผ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ์š”? (์ข…๋ฃŒํ•˜๋ ค๋ฉด '์ข…๋ฃŒ' ์ž…๋ ฅ)")
        print("-" * 50)
        
        while True:
            user_input = input("๋‹น์‹ : ")
            
            if user_input.lower() in ['์ข…๋ฃŒ', 'quit', 'exit']:
                print("์ฑ—๋ด‡: ์•ˆ๋…•ํžˆ ๊ฐ€์„ธ์š”! ๐Ÿ‘‹")
                break
            
            response = self.get_response(user_input)
            print(f"์ฑ—๋ด‡: {response}")
            print()

# ์ฑ—๋ด‡ ์‹คํ–‰
if __name__ == "__main__":
    bot = SimpleChatbot()
    bot.start()

๐Ÿ’ก ์ฝ”๋“œ ์„ค๋ช… ์ด ์ฝ”๋“œ๋Š” ๋”•์…”๋„ˆ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ํ‚ค์›Œ๋“œ์™€ ์‘๋‹ต์„ ๋งค์นญํ•ด. ์‚ฌ์šฉ์ž๊ฐ€ "์•ˆ๋…•"์ด๋ผ๊ณ  ์ž…๋ ฅํ•˜๋ฉด, ๋”•์…”๋„ˆ๋ฆฌ์—์„œ "์•ˆ๋…•" ํ‚ค๋ฅผ ์ฐพ์•„์„œ ํ•ด๋‹น ์‘๋‹ต์„ ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฑฐ์•ผ. ๊ฐ„๋‹จํ•˜์ง€๋งŒ ์ฑ—๋ด‡์˜ ๊ธฐ๋ณธ ์›๋ฆฌ๋ฅผ ์ดํ•ดํ•˜๊ธฐ์— ์™„๋ฒฝํ•ด! ๐ŸŽฏ

๐ŸŒ ์›น ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡์œผ๋กœ ์—…๊ทธ๋ ˆ์ด๋“œ

์ฝ˜์†”์—์„œ๋งŒ ์ž‘๋™ํ•˜๋Š” ๊ฑด ์ข€ ์‹ฌ์‹ฌํ•˜์ง€? Flask๋ฅผ ์‚ฌ์šฉํ•ด์„œ ์›น ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž!

# web_chatbot.py
from flask import Flask, render_template, request, jsonify

app = Flask(__name__)

class WebChatbot:
    def __init__(self):
        self.responses = {
            "์•ˆ๋…•": "์•ˆ๋…•ํ•˜์„ธ์š”! ์›น ์ฑ—๋ด‡์ž…๋‹ˆ๋‹ค! ๐ŸŒ",
            "๊ธฐ๋Šฅ": "์ €๋Š” ๊ฐ„๋‹จํ•œ ์งˆ๋ฌธ์— ๋‹ต๋ณ€ํ•  ์ˆ˜ ์žˆ์–ด์š”!",
            "์‹œ๊ฐ„": "์ฃ„์†กํ•ด์š”, ์‹œ๊ฐ„ ๊ธฐ๋Šฅ์€ ์•„์ง ๊ฐœ๋ฐœ ์ค‘์ด์—์š”. โฐ",
            "๋„์›€": "๋ฌด์—‡์ด๋“  ๋ฌผ์–ด๋ณด์„ธ์š”! ์ตœ์„ ์„ ๋‹คํ•ด ๋‹ต๋ณ€ํ• ๊ฒŒ์š”.",
        }
    
    def get_response(self, message):
        message = message.lower().strip()
        for keyword, response in self.responses.items():
            if keyword in message:
                return response
        return "ํฅ๋ฏธ๋กœ์šด ์งˆ๋ฌธ์ด๋„ค์š”! ๋” ๊ณต๋ถ€ํ•ด์„œ ๋‹ต๋ณ€๋“œ๋ฆด๊ฒŒ์š”. ๐Ÿ“š"

chatbot = WebChatbot()

@app.route('/')
def home():
    return '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>์›น ์ฑ—๋ด‡</title>
        <style>.tx-header{background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);
color:#fff;
padding:40px 30px;
border-radius:16px;
text-align:center;
margin-bottom:40px;
box-shadow:0 8px 24px rgba(102,126,234,0.25);}
.tx-intro{background:#f8f9fa;
padding:25px;
border-radius:12px;
margin:30px 0;
border-left:5px solid #667eea;}
.tx-section{margin:40px 0;}
.tx-highlight{background:linear-gradient(120deg,#ffeaa7 0%,#fdcb6e 100%);
padding:3px 8px;
border-radius:4px;
font-weight:600;}
.tx-tip{background:#e8f5e9;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:4px solid #4caf50;}
.tx-warning{background:#fff3e0;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:4px solid #ff9800;}
.tx-point{color:#667eea;
font-weight:700;}
.tx-subtitle{color:#764ba2;
font-weight:600;
font-size:1.1em;
margin:20px 0 10px 0;}
.tx-card{background:#ffffff;
padding:20px;
border-radius:12px;
margin:20px 0;
box-shadow:0 4px 12px rgba(0,0,0,0.08);}
.tx-step{background:#f1f3f5;
padding:15px 20px;
border-radius:8px;
margin:15px 0;
border-left:3px solid #667eea;}</style>
    </head>
    <body>
        <h1 style="text-align:center; color:#667eea;">๐Ÿค– ์›น ์ฑ—๋ด‡</h1>
        <div id="chat-box"></div>
        <div id="input-area">
            <input type="text" id="user-input" placeholder="๋ฉ”์‹œ์ง€๋ฅผ ์ž…๋ ฅํ•˜์„ธ์š”...">
            <button id="send-btn" onclick="sendMessage()">์ „์†ก</button>
        </div>
        
        <script>
            function sendMessage() {
                const input = document.getElementById('user-input');
                const message = input.value.trim();
                if (!message) return;
                
                // ์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€ ํ‘œ์‹œ
                addMessage(message, 'user');
                input.value = '';
                
                // ์„œ๋ฒ„์— ๋ฉ”์‹œ์ง€ ์ „์†ก
                fetch('/chat', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ message: message })
                })
                .then(response => response.json())
                .then(data => {
                    addMessage(data.response, 'bot');
                });
            }
            
            function addMessage(text, sender) {
                const chatBox = document.getElementById('chat-box');
                const messageDiv = document.createElement('div');
                messageDiv.className = 'message ' + sender;
                messageDiv.textContent = text;
                chatBox.appendChild(messageDiv);
                chatBox.scrollTop = chatBox.scrollHeight;
            }
            
            // ์—”ํ„ฐํ‚ค๋กœ ์ „์†ก
            document.getElementById('user-input').addEventListener('keypress', function(e) {
                if (e.key === 'Enter') sendMessage();
            });
        </script>
    </body>
    </html>
    '''

@app.route('/chat', methods=['POST'])
def chat():
    user_message = request.json['message']
    bot_response = chatbot.get_response(user_message)
    return jsonify({'response': bot_response})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

์ด์ œ ๋ธŒ๋ผ์šฐ์ €์—์„œ http://localhost:5000์œผ๋กœ ์ ‘์†ํ•˜๋ฉด ๋ฉ‹์ง„ ์›น ์ฑ—๋ด‡์„ ๋งŒ๋‚  ์ˆ˜ ์žˆ์–ด! ๐ŸŽŠ

๐Ÿง  AI ๋Œ€ํ™” ์—”์ง„์˜ ํ•ต์‹ฌ: ์ž์—ฐ์–ด ์ฒ˜๋ฆฌ(NLP)

๊ทœ์น™ ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡์€ ํ•œ๊ณ„๊ฐ€ ๋ช…ํ™•ํ•ด. "์•ˆ๋…•ํ•˜์„ธ์š”"๋Š” ์ดํ•ดํ•˜์ง€๋งŒ "ํ•˜์ด~"๋Š” ๋ชป ์•Œ์•„๋“ฃ๋Š” ์‹์ด์ง€. ์ง„์งœ ๋˜‘๋˜‘ํ•œ ์ฑ—๋ด‡์„ ๋งŒ๋“ค๋ ค๋ฉด ์ž์—ฐ์–ด ์ฒ˜๋ฆฌ ๊ธฐ์ˆ ์ด ํ•„์š”ํ•ด! ๐ŸŽ“

๐Ÿ” NLP์˜ ์ฃผ์š” ๊ธฐ์ˆ ๋“ค

1. ํ† ํฐํ™”(Tokenization) โœ‚๏ธ
๋ฌธ์žฅ์„ ๋‹จ์–ด๋‚˜ ํ˜•ํƒœ์†Œ ๋‹จ์œ„๋กœ ์ชผ๊ฐœ๋Š” ๊ฑฐ์•ผ. "๋‚˜๋Š” ๋ฐฅ์„ ๋จน์—ˆ๋‹ค" โ†’ ["๋‚˜๋Š”", "๋ฐฅ์„", "๋จน์—ˆ๋‹ค"]

2. ํ˜•ํƒœ์†Œ ๋ถ„์„(Morphological Analysis) ๐Ÿ”ฌ
๋‹จ์–ด์˜ ๊ธฐ๋ณธํ˜•์„ ์ฐพ์•„๋‚ด. "๋จน์—ˆ๋‹ค" โ†’ "๋จน๋‹ค" (๋™์‚ฌ ์›ํ˜•)

3. ๊ฐœ์ฒด๋ช… ์ธ์‹(NER: Named Entity Recognition) ๐Ÿท๏ธ
๋ฌธ์žฅ์—์„œ ์‚ฌ๋žŒ ์ด๋ฆ„, ์žฅ์†Œ, ๋‚ ์งœ ๋“ฑ์„ ์ฐพ์•„๋‚ด. "๋‚ด์ผ ์„œ์šธ์—์„œ ๋งŒ๋‚˜์ž" โ†’ ์‹œ๊ฐ„(๋‚ด์ผ), ์žฅ์†Œ(์„œ์šธ)

4. ๊ฐ์ • ๋ถ„์„(Sentiment Analysis) ๐Ÿ˜Š๐Ÿ˜ข
๋ฌธ์žฅ์˜ ๊ธ์ •/๋ถ€์ •/์ค‘๋ฆฝ์„ ํŒ๋‹จํ•ด. ๊ณ ๊ฐ ๋งŒ์กฑ๋„ ์กฐ์‚ฌ์— ์œ ์šฉํ•˜์ง€!

5. ์˜๋„ ๋ถ„๋ฅ˜(Intent Classification) ๐ŸŽฏ
์‚ฌ์šฉ์ž๊ฐ€ ๋ญ˜ ์›ํ•˜๋Š”์ง€ ํŒŒ์•…ํ•ด. "ํ”ผ์ž ์ฃผ๋ฌธํ•˜๊ณ  ์‹ถ์–ด" โ†’ ์˜๋„: ์ฃผ๋ฌธ

๐Ÿ“š NLTK๋ฅผ ํ™œ์šฉํ•œ ๊ธฐ๋ณธ NLP

# nlp_chatbot.py
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer
import string

# ํ•„์š”ํ•œ ๋ฐ์ดํ„ฐ ๋‹ค์šด๋กœ๋“œ (์ตœ์ดˆ 1ํšŒ)
# nltk.download('punkt')
# nltk.download('stopwords')

class NLPChatbot:
    def __init__(self):
        self.stemmer = PorterStemmer()
        self.stop_words = set(stopwords.words('english'))
        
        # ์˜๋„๋ณ„ ํ‚ค์›Œ๋“œ์™€ ์‘๋‹ต
        self.intents = {
            'greeting': {
                'keywords': ['hello', 'hi', 'hey', 'greetings'],
                'responses': [
                    "Hello! How can I help you today? ๐Ÿ˜Š",
                    "Hi there! What can I do for you?",
                    "Hey! Nice to meet you!"
                ]
            },
            'goodbye': {
                'keywords': ['bye', 'goodbye', 'see you', 'farewell'],
                'responses': [
                    "Goodbye! Have a great day! ๐Ÿ‘‹",
                    "See you later!",
                    "Take care!"
                ]
            },
            'thanks': {
                'keywords': ['thank', 'thanks', 'appreciate'],
                'responses': [
                    "You're welcome! ๐Ÿ˜Š",
                    "Happy to help!",
                    "Anytime!"
                ]
            },
            'help': {
                'keywords': ['help', 'assist', 'support'],
                'responses': [
                    "I'm here to help! What do you need?",
                    "Sure! Tell me what you need assistance with.",
                    "I'd be happy to help you!"
                ]
            }
        }
    
    def preprocess(self, text):
        """ํ…์ŠคํŠธ ์ „์ฒ˜๋ฆฌ"""
        # ์†Œ๋ฌธ์ž ๋ณ€ํ™˜
        text = text.lower()
        
        # ํ† ํฐํ™”
        tokens = word_tokenize(text)
        
        # ๊ตฌ๋‘์  ์ œ๊ฑฐ
        tokens = [word for word in tokens if word not in string.punctuation]
        
        # ๋ถˆ์šฉ์–ด ์ œ๊ฑฐ
        tokens = [word for word in tokens if word not in self.stop_words]
        
        # ์–ด๊ฐ„ ์ถ”์ถœ
        tokens = [self.stemmer.stem(word) for word in tokens]
        
        return tokens
    
    def classify_intent(self, tokens):
        """์˜๋„ ๋ถ„๋ฅ˜"""
        for intent, data in self.intents.items():
            keywords = [self.stemmer.stem(kw) for kw in data['keywords']]
            for token in tokens:
                if token in keywords:
                    return intent
        return None
    
    def get_response(self, user_input):
        """์‘๋‹ต ์ƒ์„ฑ"""
        import random
        
        # ์ „์ฒ˜๋ฆฌ
        tokens = self.preprocess(user_input)
        
        # ์˜๋„ ๋ถ„๋ฅ˜
        intent = self.classify_intent(tokens)
        
        # ์‘๋‹ต ์„ ํƒ
        if intent:
            responses = self.intents[intent]['responses']
            return random.choice(responses)
        else:
            return "I'm not sure I understand. Could you rephrase that? ๐Ÿค”"

# ์‚ฌ์šฉ ์˜ˆ์‹œ
if __name__ == "__main__":
    bot = NLPChatbot()
    
    print("NLP Chatbot: Hello! I'm an NLP-powered chatbot. (Type 'quit' to exit)")
    print("-" * 60)
    
    while True:
        user_input = input("You: ")
        if user_input.lower() in ['quit', 'exit']:
            print("Bot: Goodbye! ๐Ÿ‘‹")
            break
        
        response = bot.get_response(user_input)
        print(f"Bot: {response}\n")

๐Ÿ’ก ํ•œ๊ตญ์–ด NLP๋Š”? ํ•œ๊ตญ์–ด๋Š” ์˜์–ด๋ณด๋‹ค ๋ณต์žกํ•ด! ์กฐ์‚ฌ, ์–ด๋ฏธ ๋ณ€ํ™”๊ฐ€ ๋งŽ๊ฑฐ๋“ . ํ•œ๊ตญ์–ด NLP์—๋Š” KoNLPy, Mecab, Okt(Twitter) ๊ฐ™์€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•ด. ํ˜•ํƒœ์†Œ ๋ถ„์„์ด ํ•ต์‹ฌ์ด์•ผ!

๐Ÿค– ๋จธ์‹ ๋Ÿฌ๋‹ ๊ธฐ๋ฐ˜ ์ฑ—๋ด‡ ๋งŒ๋“ค๊ธฐ

์ด์ œ ์ง„์งœ AI์˜ ์˜์—ญ์œผ๋กœ ๋“ค์–ด๊ฐ€๋ณด์ž! ๋จธ์‹ ๋Ÿฌ๋‹์„ ์‚ฌ์šฉํ•˜๋ฉด ์ฑ—๋ด‡์ด ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ํ•™์Šตํ•ด์„œ ์ ์  ๋˜‘๋˜‘ํ•ด์ ธ. ๐Ÿš€

๐ŸŽ“ ์˜๋„ ๋ถ„๋ฅ˜ ๋ชจ๋ธ ํ•™์Šตํ•˜๊ธฐ

# ml_chatbot.py
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
import pickle

class MLChatbot:
    def __init__(self):
        # ํ•™์Šต ๋ฐ์ดํ„ฐ
        self.training_data = [
            # ์ธ์‚ฌ
            ("์•ˆ๋…•ํ•˜์„ธ์š”", "greeting"),
            ("์•ˆ๋…•", "greeting"),
            ("ํ•˜์ด", "greeting"),
            ("๋ฐ˜๊ฐ‘์Šต๋‹ˆ๋‹ค", "greeting"),
            ("์ข‹์€ ์•„์นจ", "greeting"),
            
            # ์ž‘๋ณ„
            ("์•ˆ๋…•ํžˆ ๊ฐ€์„ธ์š”", "goodbye"),
            ("์ž˜๊ฐ€", "goodbye"),
            ("๋‹ค์Œ์— ๋ด", "goodbye"),
            ("๋˜ ๋งŒ๋‚˜์š”", "goodbye"),
            
            # ๊ฐ์‚ฌ
            ("๊ณ ๋งˆ์›Œ", "thanks"),
            ("๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค", "thanks"),
            ("๊ณ ๋ง™์Šต๋‹ˆ๋‹ค", "thanks"),
            ("๋•กํ", "thanks"),
            
            # ๋„์›€ ์š”์ฒญ
            ("๋„์™€์ค˜", "help"),
            ("๋„์›€์ด ํ•„์š”ํ•ด", "help"),
            ("์–ด๋–ป๊ฒŒ ํ•ด", "help"),
            ("๋ชจ๋ฅด๊ฒ ์–ด", "help"),
            
            # ์ฃผ๋ฌธ
            ("์ฃผ๋ฌธํ•˜๊ณ  ์‹ถ์–ด", "order"),
            ("๊ตฌ๋งคํ• ๊ฒŒ", "order"),
            ("์‚ฌ๊ณ  ์‹ถ์–ด", "order"),
            ("์žฅ๋ฐ”๊ตฌ๋‹ˆ", "order"),
            
            # ๋ฐฐ์†ก
            ("๋ฐฐ์†ก ์–ธ์ œ ์™€", "delivery"),
            ("๋ฐฐ์†ก ์กฐํšŒ", "delivery"),
            ("์–ธ์ œ ๋„์ฐฉํ•ด", "delivery"),
            ("๋ฐฐ์†ก ์ƒํƒœ", "delivery"),
        ]
        
        # ์‘๋‹ต ํ…œํ”Œ๋ฆฟ
        self.responses = {
            "greeting": [
                "์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”? ๐Ÿ˜Š",
                "๋ฐ˜๊ฐ‘์Šต๋‹ˆ๋‹ค! ๊ถ๊ธˆํ•œ ์ ์ด ์žˆ์œผ์‹ ๊ฐ€์š”?",
                "์•ˆ๋…•ํ•˜์„ธ์š”! ์˜ค๋Š˜ ํ•˜๋ฃจ ์–ด๋– ์„ธ์š”?"
            ],
            "goodbye": [
                "์•ˆ๋…•ํžˆ ๊ฐ€์„ธ์š”! ์ข‹์€ ํ•˜๋ฃจ ๋˜์„ธ์š”! ๐Ÿ‘‹",
                "๋˜ ๋งŒ๋‚˜์š”! ์–ธ์ œ๋“  ์ฐพ์•„์ฃผ์„ธ์š”!",
                "๋‹ค์Œ์— ๋˜ ๋ต™๊ฒ ์Šต๋‹ˆ๋‹ค!"
            ],
            "thanks": [
                "์ฒœ๋งŒ์—์š”! ๋” ๋„์™€๋“œ๋ฆด ๊ฒŒ ์žˆ๋‚˜์š”? ๐Ÿ˜Š",
                "๋ณ„๋ง์”€์„์š”! ์–ธ์ œ๋“  ๋ฌผ์–ด๋ณด์„ธ์š”!",
                "๋„์›€์ด ๋˜์—ˆ๋‹ค๋‹ˆ ๊ธฐ์ฉ๋‹ˆ๋‹ค!"
            ],
            "help": [
                "๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”? ์ž์„ธํžˆ ๋ง์”€ํ•ด์ฃผ์„ธ์š”!",
                "์ œ๊ฐ€ ๋„์™€๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค! ์–ด๋–ค ๋ถ€๋ถ„์ด ๊ถ๊ธˆํ•˜์‹ ๊ฐ€์š”?",
                "๋ฌธ์ œ๋ฅผ ํ•จ๊ป˜ ํ•ด๊ฒฐํ•ด๋ด์š”! ๐Ÿค"
            ],
            "order": [
                "์ฃผ๋ฌธํ•˜์‹œ๋ ค๋Š” ์ƒํ’ˆ์„ ์•Œ๋ ค์ฃผ์„ธ์š”!",
                "์–ด๋–ค ์ œํ’ˆ์„ ๊ตฌ๋งคํ•˜๊ณ  ์‹ถ์œผ์‹ ๊ฐ€์š”?",
                "์žฅ๋ฐ”๊ตฌ๋‹ˆ์— ๋‹ด์œผ์‹ค ์ƒํ’ˆ์„ ์„ ํƒํ•ด์ฃผ์„ธ์š”! ๐Ÿ›’"
            ],
            "delivery": [
                "์ฃผ๋ฌธ๋ฒˆํ˜ธ๋ฅผ ์•Œ๋ ค์ฃผ์‹œ๋ฉด ๋ฐฐ์†ก ์ƒํƒœ๋ฅผ ํ™•์ธํ•ด๋“œ๋ฆด๊ฒŒ์š”!",
                "๋ฐฐ์†ก ์กฐํšŒ๋Š” ๋งˆ์ดํŽ˜์ด์ง€์—์„œ๋„ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค! ๐Ÿ“ฆ",
                "๋ฐฐ์†ก ๊ด€๋ จ ๋ฌธ์˜๋Š” ๊ณ ๊ฐ์„ผํ„ฐ๋กœ ์—ฐ๊ฒฐํ•ด๋“œ๋ฆด๊นŒ์š”?"
            ]
        }
        
        self.model = None
        self.train()
    
    def train(self):
        """๋ชจ๋ธ ํ•™์Šต"""
        # ๋ฐ์ดํ„ฐ ๋ถ„๋ฆฌ
        X = [text for text, label in self.training_data]
        y = [label for text, label in self.training_data]
        
        # ํŒŒ์ดํ”„๋ผ์ธ ์ƒ์„ฑ (TF-IDF + Naive Bayes)
        self.model = Pipeline([
            ('tfidf', TfidfVectorizer(
                analyzer='char',  # ํ•œ๊ตญ์–ด๋Š” ๋ฌธ์ž ๋‹จ์œ„๊ฐ€ ํšจ๊ณผ์ 
                ngram_range=(2, 4)  # 2~4๊ธ€์ž ์กฐํ•ฉ
            )),
            ('clf', MultinomialNB())
        ])
        
        # ํ•™์Šต
        self.model.fit(X, y)
        print("โœ… ๋ชจ๋ธ ํ•™์Šต ์™„๋ฃŒ!")
    
    def predict_intent(self, text):
        """์˜๋„ ์˜ˆ์ธก"""
        if self.model is None:
            return None
        
        intent = self.model.predict([text])[0]
        probability = self.model.predict_proba([text]).max()
        
        # ์‹ ๋ขฐ๋„๊ฐ€ ๋‚ฎ์œผ๋ฉด None ๋ฐ˜ํ™˜
        if probability < 0.5:
            return None
        
        return intent
    
    def get_response(self, user_input):
        """์‘๋‹ต ์ƒ์„ฑ"""
        import random
        
        intent = self.predict_intent(user_input)
        
        if intent and intent in self.responses:
            return random.choice(self.responses[intent])
        else:
            return "์ฃ„์†กํ•ด์š”, ์ž˜ ์ดํ•ดํ•˜์ง€ ๋ชปํ–ˆ์–ด์š”. ๋‹ค์‹œ ๋ง์”€ํ•ด์ฃผ์‹œ๊ฒ ์–ด์š”? ๐Ÿค”"
    
    def save_model(self, filename='chatbot_model.pkl'):
        """๋ชจ๋ธ ์ €์žฅ"""
        with open(filename, 'wb') as f:
            pickle.dump(self.model, f)
        print(f"โœ… ๋ชจ๋ธ์ด {filename}์— ์ €์žฅ๋˜์—ˆ์Šต๋‹ˆ๋‹ค!")
    
    def load_model(self, filename='chatbot_model.pkl'):
        """๋ชจ๋ธ ๋ถˆ๋Ÿฌ์˜ค๊ธฐ"""
        with open(filename, 'rb') as f:
            self.model = pickle.load(f)
        print(f"โœ… ๋ชจ๋ธ์„ {filename}์—์„œ ๋ถˆ๋Ÿฌ์™”์Šต๋‹ˆ๋‹ค!")

# ์‹คํ–‰ ์˜ˆ์‹œ
if __name__ == "__main__":
    bot = MLChatbot()
    
    print("ML Chatbot: ์•ˆ๋…•ํ•˜์„ธ์š”! ๋จธ์‹ ๋Ÿฌ๋‹ ์ฑ—๋ด‡์ž…๋‹ˆ๋‹ค. (์ข…๋ฃŒ: 'quit')")
    print("-" * 60)
    
    while True:
        user_input = input("๋‹น์‹ : ")
        if user_input.lower() in ['quit', 'exit', '์ข…๋ฃŒ']:
            print("Bot: ์•ˆ๋…•ํžˆ ๊ฐ€์„ธ์š”! ๐Ÿ‘‹")
            break
        
        response = bot.get_response(user_input)
        print(f"Bot: {response}\n")
    
    # ๋ชจ๋ธ ์ €์žฅ
    bot.save_model()

๐ŸŽฏ ์ฝ”๋“œ ํ•ต์‹ฌ ํฌ์ธํŠธ

TF-IDF (Term Frequency-Inverse Document Frequency)
๋‹จ์–ด์˜ ์ค‘์š”๋„๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ๋ฐฉ๋ฒ•์ด์•ผ. ์ž์ฃผ ๋‚˜์˜ค์ง€๋งŒ ๋ชจ๋“  ๋ฌธ์„œ์— ๋‚˜์˜ค๋Š” ๋‹จ์–ด(์˜ˆ: "์€", "๋Š”")๋Š” ์ค‘์š”๋„๊ฐ€ ๋‚ฎ๊ณ , ํŠน์ • ๋ฌธ์„œ์—๋งŒ ๋‚˜์˜ค๋Š” ๋‹จ์–ด๋Š” ์ค‘์š”๋„๊ฐ€ ๋†’์•„. ๐Ÿ“Š

Naive Bayes ๋ถ„๋ฅ˜๊ธฐ
ํ™•๋ฅ  ๊ธฐ๋ฐ˜ ๋ถ„๋ฅ˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด์•ผ. "์ด ๋ฌธ์žฅ์ด ์ธ์‚ฌ์ผ ํ™•๋ฅ ์€ 80%, ์ž‘๋ณ„ ์ธ์‚ฌ์ผ ํ™•๋ฅ ์€ 20%"์ฒ˜๋Ÿผ ๊ณ„์‚ฐํ•ด์„œ ๊ฐ€์žฅ ํ™•๋ฅ  ๋†’์€ ๊ฑธ ์„ ํƒํ•˜์ง€. ๊ฐ„๋‹จํ•˜์ง€๋งŒ ํšจ๊ณผ์ ์ด์•ผ! ๐ŸŽฒ

Character N-gram
ํ•œ๊ตญ์–ด๋Š” ๋„์–ด์“ฐ๊ธฐ๊ฐ€ ๋ถˆ๊ทœ์น™ํ•˜๊ณ  ์กฐ์‚ฌ ๋ณ€ํ™”๊ฐ€ ๋งŽ์•„์„œ, ๋ฌธ์ž ๋‹จ์œ„๋กœ ๋ถ„์„ํ•˜๋Š” ๊ฒŒ ํšจ๊ณผ์ ์ด์•ผ. "์•ˆ๋…•ํ•˜์„ธ์š”" โ†’ ["์•ˆ๋…•", "๋…•ํ•˜", "ํ•˜์„ธ", "์„ธ์š”"] ์ด๋Ÿฐ ์‹์œผ๋กœ!

๐ŸŒŸ ๋”ฅ๋Ÿฌ๋‹ ๊ธฐ๋ฐ˜ ๊ณ ๊ธ‰ ์ฑ—๋ด‡

์ด์ œ ์ตœ์‹  ๊ธฐ์ˆ ์˜ ์ •์ , ๋”ฅ๋Ÿฌ๋‹ ์ฑ—๋ด‡์„ ๋งŒ๋“ค์–ด๋ณด์ž! ํŠธ๋žœ์Šคํฌ๋จธ, BERT, GPT ๊ฐ™์€ ์šฉ์–ด๋“ค ๋“ค์–ด๋ดค์ง€? ์ด๊ฒŒ ๋ฐ”๋กœ ๊ทธ๊ฑฐ์•ผ! ๐Ÿ”ฅ

๐Ÿงฌ Seq2Seq ๋ชจ๋ธ์˜ ์ดํ•ด

Sequence-to-Sequence ๋ชจ๋ธ์€ ์ž…๋ ฅ ์‹œํ€€์Šค๋ฅผ ๋ฐ›์•„์„œ ์ถœ๋ ฅ ์‹œํ€€์Šค๋ฅผ ์ƒ์„ฑํ•ด. ๋ฒˆ์—ญ๊ธฐ๋‚˜ ์ฑ—๋ด‡์— ๋”ฑ์ด์ง€! ๊ตฌ์กฐ๋Š” ์ด๋ž˜:

์ธ์ฝ”๋”(Encoder) ๐Ÿ“ฅ ์‚ฌ์šฉ์ž ์ž…๋ ฅ์„ ๋ฐ›์•„์„œ ์˜๋ฏธ๋ฅผ ์••์ถ•๋œ ๋ฒกํ„ฐ๋กœ ๋ณ€ํ™˜ํ•ด. "์•ˆ๋…•ํ•˜์„ธ์š”" โ†’ [0.2, 0.8, 0.1, ...]

๋””์ฝ”๋”(Decoder) ๐Ÿ“ค
์••์ถ•๋œ ๋ฒกํ„ฐ๋ฅผ ๋ฐ›์•„์„œ ์‘๋‹ต์„ ๋‹จ์–ด ํ•˜๋‚˜์”ฉ ์ƒ์„ฑํ•ด. [0.2, 0.8, 0.1, ...] โ†’ "์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”?"

์–ดํ…์…˜(Attention) ๐Ÿ‘€
์ž…๋ ฅ์˜ ์–ด๋А ๋ถ€๋ถ„์— ์ง‘์ค‘ํ•ด์•ผ ํ•˜๋Š”์ง€ ์•Œ๋ ค์ค˜. ๊ธด ๋ฌธ์žฅ๋„ ์ •ํ™•ํ•˜๊ฒŒ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋Š” ํ•ต์‹ฌ ๊ธฐ์ˆ !

๐Ÿ’ป TensorFlow๋กœ ๊ฐ„๋‹จํ•œ Seq2Seq ์ฑ—๋ด‡

# seq2seq_chatbot.py
import tensorflow as tf
from tensorflow.keras.layers import Input, LSTM, Dense, Embedding
from tensorflow.keras.models import Model
import numpy as np

class Seq2SeqChatbot:
    def __init__(self, vocab_size=5000, embedding_dim=256, hidden_units=512):
        self.vocab_size = vocab_size
        self.embedding_dim = embedding_dim
        self.hidden_units = hidden_units
        
        # ๋‹จ์–ด-์ธ๋ฑ์Šค ๋งคํ•‘ (์‹ค์ œ๋กœ๋Š” ํ•™์Šต ๋ฐ์ดํ„ฐ์—์„œ ์ƒ์„ฑ)
        self.word2idx = {}
        self.idx2word = {}
        
        self.encoder_model = None
        self.decoder_model = None
        
    def build_model(self):
        """Seq2Seq ๋ชจ๋ธ ๊ตฌ์ถ•"""
        
        # ์ธ์ฝ”๋”
        encoder_inputs = Input(shape=(None,))
        encoder_embedding = Embedding(self.vocab_size, self.embedding_dim)(encoder_inputs)
        encoder_lstm = LSTM(self.hidden_units, return_state=True)
        encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
        encoder_states = [state_h, state_c]
        
        # ๋””์ฝ”๋”
        decoder_inputs = Input(shape=(None,))
        decoder_embedding = Embedding(self.vocab_size, self.embedding_dim)(decoder_inputs)
        decoder_lstm = LSTM(self.hidden_units, return_sequences=True, return_state=True)
        decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=encoder_states)
        decoder_dense = Dense(self.vocab_size, activation='softmax')
        decoder_outputs = decoder_dense(decoder_outputs)
        
        # ์ „์ฒด ๋ชจ๋ธ
        model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
        model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
        
        print("โœ… Seq2Seq ๋ชจ๋ธ ๊ตฌ์ถ• ์™„๋ฃŒ!")
        return model
    
    def build_inference_models(self, training_model):
        """์ถ”๋ก ์šฉ ์ธ์ฝ”๋”/๋””์ฝ”๋” ๋ชจ๋ธ ๋ถ„๋ฆฌ"""
        
        # ์ธ์ฝ”๋” ๋ชจ๋ธ
        encoder_inputs = training_model.input[0]
        encoder_outputs, state_h, state_c = training_model.layers[2].output
        self.encoder_model = Model(encoder_inputs, [state_h, state_c])
        
        # ๋””์ฝ”๋” ๋ชจ๋ธ
        decoder_inputs = training_model.input[1]
        decoder_state_input_h = Input(shape=(self.hidden_units,))
        decoder_state_input_c = Input(shape=(self.hidden_units,))
        decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
        
        decoder_embedding = training_model.layers[3]
        decoder_lstm = training_model.layers[4]
        decoder_dense = training_model.layers[5]
        
        decoder_embedded = decoder_embedding(decoder_inputs)
        decoder_outputs, state_h, state_c = decoder_lstm(
            decoder_embedded, initial_state=decoder_states_inputs
        )
        decoder_states = [state_h, state_c]
        decoder_outputs = decoder_dense(decoder_outputs)
        
        self.decoder_model = Model(
            [decoder_inputs] + decoder_states_inputs,
            [decoder_outputs] + decoder_states
        )
        
        print("โœ… ์ถ”๋ก  ๋ชจ๋ธ ๊ตฌ์ถ• ์™„๋ฃŒ!")
    
    def decode_sequence(self, input_seq):
        """์ž…๋ ฅ ์‹œํ€€์Šค๋ฅผ ์‘๋‹ต์œผ๋กœ ๋””์ฝ”๋”ฉ"""
        
        # ์ธ์ฝ”๋”๋กœ ์ƒํƒœ ๋ฒกํ„ฐ ์–ป๊ธฐ
        states_value = self.encoder_model.predict(input_seq)
        
        # ์‹œ์ž‘ ํ† ํฐ์œผ๋กœ ํƒ€๊ฒŸ ์‹œํ€€์Šค ์ดˆ๊ธฐํ™”
        target_seq = np.zeros((1, 1))
        target_seq[0, 0] = self.word2idx.get('<start>', 1)
        
        # ์‘๋‹ต ์ƒ์„ฑ
        decoded_sentence = []
        max_length = 50
        
        for _ in range(max_length):
            output_tokens, h, c = self.decoder_model.predict([target_seq] + states_value)
            
            # ๊ฐ€์žฅ ํ™•๋ฅ  ๋†’์€ ๋‹จ์–ด ์„ ํƒ
            sampled_token_index = np.argmax(output_tokens[0, -1, :])
            sampled_word = self.idx2word.get(sampled_token_index, '<unk>')
            
            # ์ข…๋ฃŒ ํ† ํฐ์ด๋ฉด ์ค‘๋‹จ
            if sampled_word == '<end>':
                break
            
            decoded_sentence.append(sampled_word)
            
            # ๋‹ค์Œ ์ž…๋ ฅ ์ค€๋น„
            target_seq = np.zeros((1, 1))
            target_seq[0, 0] = sampled_token_index
            states_value = [h, c]
        
        return ' '.join(decoded_sentence)
    
    def prepare_data(self, conversations):
        """๋Œ€ํ™” ๋ฐ์ดํ„ฐ ์ „์ฒ˜๋ฆฌ"""
        # ์‹ค์ œ ๊ตฌํ˜„์—์„œ๋Š” ํ† ํฐํ™”, ํŒจ๋”ฉ, ์ธ๋ฑ์‹ฑ ๋“ฑ ์ˆ˜ํ–‰
        # ์—ฌ๊ธฐ์„œ๋Š” ๊ฐœ๋…์  ์„ค๋ช…์„ ์œ„ํ•œ ๊ฐ„์†Œํ™” ๋ฒ„์ „
        
        input_texts = []
        target_texts = []
        
        for question, answer in conversations:
            input_texts.append(question)
            target_texts.append('<start> ' + answer + ' <end>')
        
        # ์–ดํœ˜ ์‚ฌ์ „ ๊ตฌ์ถ•
        all_words = set()
        for text in input_texts + target_texts:
            all_words.update(text.split())
        
        self.word2idx = {word: idx+2 for idx, word in enumerate(sorted(all_words))}
        self.word2idx['<pad>'] = 0
        self.word2idx['<unk>'] = 1
        self.idx2word = {idx: word for word, idx in self.word2idx.items()}
        
        print(f"โœ… ์–ดํœ˜ ํฌ๊ธฐ: {len(self.word2idx)}")
        return input_texts, target_texts

# ์‚ฌ์šฉ ์˜ˆ์‹œ
if __name__ == "__main__":
    # ํ•™์Šต ๋ฐ์ดํ„ฐ ์˜ˆ์‹œ
    conversations = [
        ("์•ˆ๋…•ํ•˜์„ธ์š”", "์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”?"),
        ("๋‚ ์”จ ์–ด๋•Œ", "์˜ค๋Š˜ ๋‚ ์”จ๋Š” ๋ง‘์Šต๋‹ˆ๋‹ค!"),
        ("๊ณ ๋งˆ์›Œ", "์ฒœ๋งŒ์—์š”! ๋˜ ๊ถ๊ธˆํ•œ ๊ฒŒ ์žˆ์œผ๋ฉด ๋ฌผ์–ด๋ณด์„ธ์š”!"),
        # ... ์‹ค์ œ๋กœ๋Š” ์ˆ˜์ฒœ~์ˆ˜๋งŒ ๊ฐœ์˜ ๋Œ€ํ™” ์Œ ํ•„์š”
    ]
    
    chatbot = Seq2SeqChatbot()
    input_texts, target_texts = chatbot.prepare_data(conversations)
    
    # ๋ชจ๋ธ ๊ตฌ์ถ•
    training_model = chatbot.build_model()
    
    print("\n๐Ÿ’ก ์‹ค์ œ ํ•™์Šต์„ ์œ„ํ•ด์„œ๋Š” ๋Œ€๋Ÿ‰์˜ ๋Œ€ํ™” ๋ฐ์ดํ„ฐ๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค!")
    print("   - ์ตœ์†Œ ์ˆ˜์ฒœ ๊ฐœ ์ด์ƒ์˜ ์งˆ๋ฌธ-๋‹ต๋ณ€ ์Œ")
    print("   - GPU ํ™˜๊ฒฝ์—์„œ ์ˆ˜ ์‹œ๊ฐ„~์ˆ˜์ผ ํ•™์Šต")
    print("   - ๋ฐ์ดํ„ฐ ํ’ˆ์งˆ์ด ์„ฑ๋Šฅ์„ ์ขŒ์šฐํ•ฉ๋‹ˆ๋‹ค!")

โš ๏ธ ๋”ฅ๋Ÿฌ๋‹ ์ฑ—๋ด‡์˜ ํ˜„์‹ค ๋”ฅ๋Ÿฌ๋‹ ์ฑ—๋ด‡์€ ๊ฐ•๋ ฅํ•˜์ง€๋งŒ ์‰ฝ์ง€ ์•Š์•„! ๋Œ€๋Ÿ‰์˜ ํ•™์Šต ๋ฐ์ดํ„ฐ, ๊ฐ•๋ ฅํ•œ ์ปดํ“จํŒ… ํŒŒ์›Œ(GPU), ๊ธด ํ•™์Šต ์‹œ๊ฐ„์ด ํ•„์š”ํ•ด. ์ฒ˜์Œ ์‹œ์ž‘ํ•œ๋‹ค๋ฉด ์‚ฌ์ „ ํ•™์Šต๋œ ๋ชจ๋ธ(Pre-trained Model)์„ ํ™œ์šฉํ•˜๋Š” ๊ฒŒ ํ˜„๋ช…ํ•ด. ๐ŸŽฏ

๐Ÿš€ ์‹ค์ „ ์ฑ—๋ด‡ ํ”„๋ ˆ์ž„์›Œํฌ ํ™œ์šฉํ•˜๊ธฐ

์ฒ˜์Œ๋ถ€ํ„ฐ ๋‹ค ๋งŒ๋“ค ํ•„์š”๋Š” ์—†์–ด! ๊ฒ€์ฆ๋œ ํ”„๋ ˆ์ž„์›Œํฌ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ํ›จ์”ฌ ๋น ๋ฅด๊ณ  ์•ˆ์ •์ ์œผ๋กœ ์ฑ—๋ด‡์„ ๊ฐœ๋ฐœํ•  ์ˆ˜ ์žˆ์ง€. ๐Ÿ› ๏ธ

๐ŸŽญ Rasa: ์˜คํ”ˆ์†Œ์Šค ๋Œ€ํ™”ํ˜• AI ํ”„๋ ˆ์ž„์›Œํฌ

Rasa๋Š” ๊ฐ€์žฅ ์ธ๊ธฐ ์žˆ๋Š” ์˜คํ”ˆ์†Œ์Šค ์ฑ—๋ด‡ ํ”„๋ ˆ์ž„์›Œํฌ์•ผ. NLU(์ž์—ฐ์–ด ์ดํ•ด)์™€ ๋Œ€ํ™” ๊ด€๋ฆฌ๋ฅผ ๋ชจ๋‘ ์ง€์›ํ•ด!

# Rasa ์„ค์น˜
pip install rasa

# ์ƒˆ ํ”„๋กœ์ ํŠธ ์ƒ์„ฑ
rasa init --no-prompt

# ํ”„๋กœ์ ํŠธ ๊ตฌ์กฐ
# my_chatbot/
# โ”œโ”€โ”€ data/
# โ”‚   โ”œโ”€โ”€ nlu.yml          # ํ•™์Šต ๋ฐ์ดํ„ฐ
# โ”‚   โ””โ”€โ”€ stories.yml      # ๋Œ€ํ™” ์‹œ๋‚˜๋ฆฌ์˜ค
# โ”œโ”€โ”€ models/              # ํ•™์Šต๋œ ๋ชจ๋ธ
# โ”œโ”€โ”€ config.yml           # ์„ค์ • ํŒŒ์ผ
# โ”œโ”€โ”€ domain.yml           # ๋„๋ฉ”์ธ ์ •์˜
# โ””โ”€โ”€ endpoints.yml        # API ์—”๋“œํฌ์ธํŠธ
# data/nlu.yml - ์˜๋„์™€ ์˜ˆ์‹œ ์ •์˜
version: "3.0"

nlu:
- intent: greet
  examples: |
    - ์•ˆ๋…•ํ•˜์„ธ์š”
    - ์•ˆ๋…•
    - ํ•˜์ด
    - ๋ฐ˜๊ฐ‘์Šต๋‹ˆ๋‹ค
    - ์ข‹์€ ์•„์นจ์ด์—์š”

- intent: goodbye
  examples: |
    - ์•ˆ๋…•ํžˆ ๊ฐ€์„ธ์š”
    - ์ž˜๊ฐ€
    - ๋‹ค์Œ์— ๋ด
    - ๋˜ ๋งŒ๋‚˜์š”
    - ๋ฐ”์ด

- intent: order_pizza
  examples: |
    - ํ”ผ์ž ์ฃผ๋ฌธํ•˜๊ณ  ์‹ถ์–ด์š”
    - ํ”ผ์ž [ํŽ˜ํผ๋กœ๋‹ˆ](pizza_type) ํ•˜๋‚˜ ์ฃผ์„ธ์š”
    - [๋งˆ๋ฅด๊ฒŒ๋ฆฌํƒ€](pizza_type) ํ”ผ์ž ์ฃผ๋ฌธํ• ๊ฒŒ์š”
    - [ํ•˜์™€์ด์•ˆ](pizza_type) ํ”ผ์ž 2ํŒ ์ฃผ๋ฌธ

- intent: check_delivery
  examples: |
    - ๋ฐฐ์†ก ์–ธ์ œ ์™€์š”
    - ์ฃผ๋ฌธํ•œ ๊ฑฐ ์–ธ์ œ ๋„์ฐฉํ•ด์š”
    - ๋ฐฐ์†ก ์กฐํšŒํ•˜๊ณ  ์‹ถ์–ด์š”
    - ๋ฐฐ์†ก ์ƒํƒœ ์•Œ๋ ค์ฃผ์„ธ์š”
# data/stories.yml - ๋Œ€ํ™” ํ๋ฆ„ ์ •์˜
version: "3.0"

stories:
- story: ์ธ์‚ฌ ํ›„ ํ”ผ์ž ์ฃผ๋ฌธ
  steps:
  - intent: greet
  - action: utter_greet
  - intent: order_pizza
  - action: utter_ask_pizza_type
  - intent: inform
    entities:
    - pizza_type
  - action: utter_confirm_order
  - action: action_process_order

- story: ๋ฐฐ์†ก ์กฐํšŒ
  steps:
  - intent: check_delivery
  - action: utter_ask_order_number
  - intent: inform
    entities:
    - order_number
  - action: action_check_delivery_status
# domain.yml - ๋„๋ฉ”์ธ ์ •์˜
version: "3.0"

intents:
  - greet
  - goodbye
  - order_pizza
  - check_delivery
  - inform

entities:
  - pizza_type
  - order_number

slots:
  pizza_type:
    type: text
    mappings:
    - type: from_entity
      entity: pizza_type
  
  order_number:
    type: text
    mappings:
    - type: from_entity
      entity: order_number

responses:
  utter_greet:
  - text: "์•ˆ๋…•ํ•˜์„ธ์š”! ํ”ผ์ž ์ฃผ๋ฌธ์„ ๋„์™€๋“œ๋ฆด๊ฒŒ์š”! ๐Ÿ•"
  
  utter_goodbye:
  - text: "๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค! ์ข‹์€ ํ•˜๋ฃจ ๋˜์„ธ์š”! ๐Ÿ‘‹"
  
  utter_ask_pizza_type:
  - text: "์–ด๋–ค ํ”ผ์ž๋ฅผ ์›ํ•˜์‹œ๋‚˜์š”? (ํŽ˜ํผ๋กœ๋‹ˆ, ๋งˆ๋ฅด๊ฒŒ๋ฆฌํƒ€, ํ•˜์™€์ด์•ˆ)"
  
  utter_confirm_order:
  - text: "{pizza_type} ํ”ผ์ž ์ฃผ๋ฌธ์ด ์ ‘์ˆ˜๋˜์—ˆ์Šต๋‹ˆ๋‹ค!"
  
  utter_ask_order_number:
  - text: "์ฃผ๋ฌธ๋ฒˆํ˜ธ๋ฅผ ์•Œ๋ ค์ฃผ์„ธ์š”!"

actions:
  - action_process_order
  - action_check_delivery_status
# actions.py - ์ปค์Šคํ…€ ์•ก์…˜ ์ •์˜
from typing import Any, Text, Dict, List
from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher

class ActionProcessOrder(Action):
    def name(self) -> Text:
        return "action_process_order"
    
    def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
        
        pizza_type = tracker.get_slot("pizza_type")
        
        # ์‹ค์ œ๋กœ๋Š” ์—ฌ๊ธฐ์„œ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค์— ์ฃผ๋ฌธ ์ €์žฅ
        order_number = "ORD-12345"  # ์˜ˆ์‹œ
        
        message = f"{pizza_type} ํ”ผ์ž ์ฃผ๋ฌธ์ด ์™„๋ฃŒ๋˜์—ˆ์Šต๋‹ˆ๋‹ค! " \
                  f"์ฃผ๋ฌธ๋ฒˆํ˜ธ๋Š” {order_number}์ž…๋‹ˆ๋‹ค. " \
                  f"์•ฝ 30๋ถ„ ํ›„ ๋ฐฐ๋‹ฌ๋  ์˜ˆ์ •์ž…๋‹ˆ๋‹ค! ๐Ÿšš"
        
        dispatcher.utter_message(text=message)
        return []

class ActionCheckDeliveryStatus(Action):
    def name(self) -> Text:
        return "action_check_delivery_status"
    
    def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
        
        order_number = tracker.get_slot("order_number")
        
        # ์‹ค์ œ๋กœ๋Š” ๋ฐฐ์†ก ์‹œ์Šคํ…œ API ํ˜ธ์ถœ
        status = "๋ฐฐ๋‹ฌ ์ค‘"  # ์˜ˆ์‹œ
        
        message = f"์ฃผ๋ฌธ๋ฒˆํ˜ธ {order_number}๋Š” ํ˜„์žฌ {status} ์ƒํƒœ์ž…๋‹ˆ๋‹ค. " \
                  f"๊ณง ๋„์ฐฉํ•  ์˜ˆ์ •์ž…๋‹ˆ๋‹ค! ๐Ÿ˜Š"
        
        dispatcher.utter_message(text=message)
        return []
# ๋ชจ๋ธ ํ•™์Šต
rasa train

# ์ฑ—๋ด‡ ์‹คํ–‰
rasa run

# ์•ก์…˜ ์„œ๋ฒ„ ์‹คํ–‰ (๋ณ„๋„ ํ„ฐ๋ฏธ๋„)
rasa run actions

# ๋Œ€ํ™” ํ…Œ์ŠคํŠธ
rasa shell

๐Ÿ’ก Rasa์˜ ์žฅ์  โ€ข ์™„์ „ํ•œ ์˜คํ”ˆ์†Œ์Šค (๋ฌด๋ฃŒ!)
โ€ข ์˜จํ”„๋ ˆ๋ฏธ์Šค ๋ฐฐํฌ ๊ฐ€๋Šฅ (๋ฐ์ดํ„ฐ ๋ณด์•ˆ ์ค‘์š”ํ•  ๋•Œ)
โ€ข ์ปค์Šคํ„ฐ๋งˆ์ด์ง• ์ž์œ ๋„ ๋†’์Œ
โ€ข ํ™œ๋ฐœํ•œ ์ปค๋ฎค๋‹ˆํ‹ฐ์™€ ํ’๋ถ€ํ•œ ๋ฌธ์„œ
โ€ข ๋‹ค๊ตญ์–ด ์ง€์› (ํ•œ๊ตญ์–ด ํฌํ•จ)

๐Ÿ’ฌ Dialogflow: ๊ตฌ๊ธ€์˜ ๋Œ€ํ™”ํ˜• AI ํ”Œ๋žซํผ

์ฝ”๋”ฉ์ด ๋ถ€๋‹ด์Šค๋Ÿฝ๋‹ค๋ฉด? Dialogflow๋Š” GUI ๊ธฐ๋ฐ˜์œผ๋กœ ์‰ฝ๊ฒŒ ์ฑ—๋ด‡์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด! ๊ตฌ๊ธ€์˜ ๊ฐ•๋ ฅํ•œ NLP ์—”์ง„์„ ์‚ฌ์šฉํ•˜์ง€. โ˜๏ธ

๐ŸŽฏ Dialogflow ์‹œ์ž‘ํ•˜๊ธฐ

1๋‹จ๊ณ„: ํ”„๋กœ์ ํŠธ ์ƒ์„ฑ
Dialogflow ์ฝ˜์†”(https://dialogflow.cloud.google.com)์— ์ ‘์†ํ•ด์„œ ์ƒˆ ์—์ด์ „ํŠธ๋ฅผ ๋งŒ๋“ค์–ด.

2๋‹จ๊ณ„: Intent ์ •์˜
Intent๋Š” ์‚ฌ์šฉ์ž์˜ ์˜๋„์•ผ. "ํ”ผ์ž ์ฃผ๋ฌธ"์ด๋ผ๋Š” Intent๋ฅผ ๋งŒ๋“ค๊ณ , ํ•™์Šต ๋ฌธ๊ตฌ๋“ค์„ ์ถ”๊ฐ€ํ•ด.

3๋‹จ๊ณ„: Entity ์ •์˜
Entity๋Š” ์ค‘์š”ํ•œ ์ •๋ณด์•ผ. "ํ”ผ์ž ์ข…๋ฅ˜", "์‚ฌ์ด์ฆˆ", "์ˆ˜๋Ÿ‰" ๊ฐ™์€ ๊ฑธ ์ถ”์ถœํ•ด.

4๋‹จ๊ณ„: Response ์ž‘์„ฑ
๊ฐ Intent์— ๋Œ€ํ•œ ์‘๋‹ต์„ ์ž‘์„ฑํ•ด. ์—ฌ๋Ÿฌ ๋ฒ„์ „์„ ๋งŒ๋“ค๋ฉด ๋žœ๋ค์œผ๋กœ ์„ ํƒ๋ผ!

5๋‹จ๊ณ„: Fulfillment ์—ฐ๊ฒฐ
๋ณต์žกํ•œ ๋กœ์ง์ด ํ•„์š”ํ•˜๋ฉด ์›นํ›…(Webhook)์œผ๋กœ ๋ฐฑ์—”๋“œ ์„œ๋ฒ„์™€ ์—ฐ๊ฒฐํ•ด.

# Dialogflow Webhook ์˜ˆ์‹œ (Flask)
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json()
    
    # Intent ์ด๋ฆ„ ๊ฐ€์ ธ์˜ค๊ธฐ
    intent_name = req['queryResult']['intent']['displayName']
    
    # ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐ€์ ธ์˜ค๊ธฐ
    parameters = req['queryResult']['parameters']
    
    # Intent๋ณ„ ์ฒ˜๋ฆฌ
    if intent_name == "์ฃผ๋ฌธํ•˜๊ธฐ":
        pizza_type = parameters.get('pizza_type')
        quantity = parameters.get('quantity', 1)
        
        # ์ฃผ๋ฌธ ์ฒ˜๋ฆฌ ๋กœ์ง
        order_number = process_order(pizza_type, quantity)
        
        response_text = f"{pizza_type} ํ”ผ์ž {quantity}ํŒ ์ฃผ๋ฌธ์ด ์™„๋ฃŒ๋˜์—ˆ์Šต๋‹ˆ๋‹ค! " \
                       f"์ฃผ๋ฌธ๋ฒˆํ˜ธ: {order_number}"
    
    elif intent_name == "๋ฐฐ์†ก์กฐํšŒ":
        order_number = parameters.get('order_number')
        
        # ๋ฐฐ์†ก ์กฐํšŒ ๋กœ์ง
        status = check_delivery(order_number)
        
        response_text = f"์ฃผ๋ฌธ๋ฒˆํ˜ธ {order_number}๋Š” ํ˜„์žฌ {status} ์ƒํƒœ์ž…๋‹ˆ๋‹ค."
    
    else:
        response_text = "์ฃ„์†กํ•ฉ๋‹ˆ๋‹ค. ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์—†๋Š” ์š”์ฒญ์ž…๋‹ˆ๋‹ค."
    
    # ์‘๋‹ต ๋ฐ˜ํ™˜
    return jsonify({
        'fulfillmentText': response_text
    })

def process_order(pizza_type, quantity):
    # ์‹ค์ œ ์ฃผ๋ฌธ ์ฒ˜๋ฆฌ ๋กœ์ง
    # ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ €์žฅ, ๊ฒฐ์ œ ์ฒ˜๋ฆฌ ๋“ฑ
    return "ORD-" + str(hash(pizza_type + str(quantity)))[:8]

def check_delivery(order_number):
    # ์‹ค์ œ ๋ฐฐ์†ก ์กฐํšŒ ๋กœ์ง
    # ๋ฐฐ์†ก ์‹œ์Šคํ…œ API ํ˜ธ์ถœ ๋“ฑ
    statuses = ["์ฃผ๋ฌธ ์ ‘์ˆ˜", "์กฐ๋ฆฌ ์ค‘", "๋ฐฐ๋‹ฌ ์ค‘", "๋ฐฐ๋‹ฌ ์™„๋ฃŒ"]
    return statuses[hash(order_number) % len(statuses)]

if __name__ == '__main__':
    app.run(port=5000)

๐ŸŽจ ์ฑ—๋ด‡ UI/UX ๋””์ž์ธ

์•„๋ฌด๋ฆฌ ๋˜‘๋˜‘ํ•œ ์ฑ—๋ด‡์ด๋ผ๋„ UI๊ฐ€ ๋ถˆํŽธํ•˜๋ฉด ์‚ฌ์šฉ์ž๋“ค์ด ๋– ๋‚˜! ์‚ฌ์šฉํ•˜๊ธฐ ํŽธํ•˜๊ณ  ์˜ˆ์œ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž. ๐Ÿ’…

๐Ÿ’ฌ ์›น ์ฑ„ํŒ… ์œ„์ ฏ ๋งŒ๋“ค๊ธฐ

<!-- chat-widget.html -->
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>์ฑ—๋ด‡ ์œ„์ ฏ</title>
    <style>.tx-header{background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);
color:#fff;
padding:40px 30px;
border-radius:16px;
text-align:center;
margin-bottom:40px;
box-shadow:0 8px 24px rgba(102,126,234,0.25);}
.tx-intro{background:#f8f9fa;
padding:25px;
border-radius:12px;
margin:30px 0;
border-left:5px solid #667eea;}
.tx-section{margin:40px 0;}
.tx-highlight{background:linear-gradient(120deg,#ffeaa7 0%,#fdcb6e 100%);
padding:3px 8px;
border-radius:4px;
font-weight:600;}
.tx-tip{background:#e8f5e9;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:4px solid #4caf50;}
.tx-warning{background:#fff3e0;
padding:20px;
border-radius:10px;
margin:25px 0;
border-left:4px solid #ff9800;}
.tx-point{color:#667eea;
font-weight:700;}
.tx-subtitle{color:#764ba2;
font-weight:600;
font-size:1.1em;
margin:20px 0 10px 0;}
.tx-card{background:#ffffff;
padding:20px;
border-radius:12px;
margin:20px 0;
box-shadow:0 4px 12px rgba(0,0,0,0.08);}
.tx-step{background:#f1f3f5;
padding:15px 20px;
border-radius:8px;
margin:15px 0;
border-left:3px solid #667eea;}</style>
</head>
<body>
    <!-- ์ฑ—๋ด‡ ๋ฒ„ํŠผ -->
    <button class="chat-button" onclick="toggleChat()">๐Ÿ’ฌ</button>
    
    <!-- ์ฑ—๋ด‡ ์ฐฝ -->
    <div class="chat-window" id="chatWindow">
        <div class="chat-header">
            <h3>๐Ÿค– AI ์ฑ—๋ด‡</h3>
            <button class="close-btn" onclick="toggleChat()">ร—</button>
        </div>
        
        <div class="chat-messages" id="chatMessages">
            <div class="message bot">
                <div class="message-content">
                    ์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”? ๐Ÿ˜Š
                    <div class="message-time">๋ฐฉ๊ธˆ ์ „</div>
                </div>
            </div>
        </div>
        
        <div class="typing-indicator" id="typingIndicator">
            <span></span>
            <span></span>
            <span></span>
        </div>
        
        <div class="chat-input-area">
            <input 
                type="text" 
                class="chat-input" 
                id="chatInput" 
                placeholder="๋ฉ”์‹œ์ง€๋ฅผ ์ž…๋ ฅํ•˜์„ธ์š”..."
                onkeypress="handleKeyPress(event)"
            >
            <button class="send-btn" onclick="sendMessage()">โžค</button>
        </div>
    </div>
    
    <script>
        // ์ฑ—๋ด‡ ํ† ๊ธ€
        function toggleChat() {
            const chatWindow = document.getElementById('chatWindow');
            chatWindow.classList.toggle('active');
            
            if (chatWindow.classList.contains('active')) {
                document.getElementById('chatInput').focus();
            }
        }
        
        // ๋ฉ”์‹œ์ง€ ์ „์†ก
        async function sendMessage() {
            const input = document.getElementById('chatInput');
            const message = input.value.trim();
            
            if (!message) return;
            
            // ์‚ฌ์šฉ์ž ๋ฉ”์‹œ์ง€ ํ‘œ์‹œ
            addMessage(message, 'user');
            input.value = '';
            
            // ํƒ€์ดํ•‘ ์ธ๋””์ผ€์ดํ„ฐ ํ‘œ์‹œ
            showTypingIndicator();
            
            // ์ฑ—๋ด‡ ์‘๋‹ต ๋ฐ›๊ธฐ (์‹ค์ œ๋กœ๋Š” API ํ˜ธ์ถœ)
            try {
                const response = await fetch('/api/chat', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({ message: message })
                });
                
                const data = await response.json();
                
                // ํƒ€์ดํ•‘ ์ธ๋””์ผ€์ดํ„ฐ ์ˆจ๊ธฐ๊ธฐ
                hideTypingIndicator();
                
                // ๋ด‡ ์‘๋‹ต ํ‘œ์‹œ
                setTimeout(() => {
                    addMessage(data.response, 'bot');
                }, 500);
                
            } catch (error) {
                hideTypingIndicator();
                addMessage('์ฃ„์†กํ•ฉ๋‹ˆ๋‹ค. ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์Šต๋‹ˆ๋‹ค. ๐Ÿ˜ข', 'bot');
            }
        }
        
        // ๋ฉ”์‹œ์ง€ ์ถ”๊ฐ€
        function addMessage(text, sender) {
            const messagesDiv = document.getElementById('chatMessages');
            const messageDiv = document.createElement('div');
            messageDiv.className = `message ${sender}`;
            
            const now = new Date();
            const timeString = now.getHours() + ':' + 
                             String(now.getMinutes()).padStart(2, '0');
            
            messageDiv.innerHTML = `
                <div class="message-content">
                    ${text}
                    <div class="message-time">${timeString}</div>
                </div>
            `;
            
            messagesDiv.appendChild(messageDiv);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
        }
        
        // ํƒ€์ดํ•‘ ์ธ๋””์ผ€์ดํ„ฐ
        function showTypingIndicator() {
            document.getElementById('typingIndicator').classList.add('active');
        }
        
        function hideTypingIndicator() {
            document.getElementById('typingIndicator').classList.remove('active');
        }
        
        // ์—”ํ„ฐํ‚ค ์ฒ˜๋ฆฌ
        function handleKeyPress(event) {
            if (event.key === 'Enter') {
                sendMessage();
            }
        }
        
        // ๋ฐ๋ชจ์šฉ ์ž๋™ ์‘๋‹ต (์‹ค์ œ๋กœ๋Š” ์„œ๋ฒ„ API ์‚ฌ์šฉ)
        async function getDemoResponse(message) {
            // ๊ฐ„๋‹จํ•œ ํ‚ค์›Œ๋“œ ๋งค์นญ
            const responses = {
                '์•ˆ๋…•': '์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฐ˜๊ฐ‘์Šต๋‹ˆ๋‹ค! ๐Ÿ˜Š',
                '๋„์›€': '๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”? ๊ถ๊ธˆํ•œ ์ ์„ ๋ง์”€ํ•ด์ฃผ์„ธ์š”!',
                '๊ณ ๋งˆ์›Œ': '์ฒœ๋งŒ์—์š”! ๋˜ ๊ถ๊ธˆํ•œ ๊ฒŒ ์žˆ์œผ๋ฉด ๋ฌผ์–ด๋ณด์„ธ์š”!',
                '์ด๋ฆ„': '์ €๋Š” AI ์ฑ—๋ด‡์ด์—์š”! ๋‹น์‹ ์˜ ์ด๋ฆ„์€ ๋ฌด์—‡์ธ๊ฐ€์š”?',
            };
            
            for (let keyword in responses) {
                if (message.includes(keyword)) {
                    return responses[keyword];
                }
            }
            
            return 'ํฅ๋ฏธ๋กœ์šด ์งˆ๋ฌธ์ด๋„ค์š”! ๋” ์ž์„ธํžˆ ๋ง์”€ํ•ด์ฃผ์‹œ๊ฒ ์–ด์š”? ๐Ÿค”';
        }
    </script>
</body>
</html>

๐Ÿ’ก UI/UX ๋””์ž์ธ ํŒ โ€ข ์‘๋‹ต ์†๋„: 2์ดˆ ์ด๋‚ด์— ์‘๋‹ตํ•ด์•ผ ์‚ฌ์šฉ์ž๊ฐ€ ๊ธฐ๋‹ค๋ ค์ค˜
โ€ข ํƒ€์ดํ•‘ ํšจ๊ณผ: ๋ด‡์ด ์ƒ๊ฐํ•˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ณด์ด๊ฒŒ ํ•˜๋ฉด ์ž์—ฐ์Šค๋Ÿฌ์›Œ
โ€ข ์—๋Ÿฌ ์ฒ˜๋ฆฌ: ์ดํ•ด ๋ชป ํ–ˆ์„ ๋•Œ๋„ ์นœ์ ˆํ•˜๊ฒŒ ์•ˆ๋‚ดํ•ด
โ€ข ๋น ๋ฅธ ๋‹ต๋ณ€ ๋ฒ„ํŠผ: ์ž์ฃผ ๋ฌป๋Š” ์งˆ๋ฌธ์€ ๋ฒ„ํŠผ์œผ๋กœ ์ œ๊ณตํ•˜๋ฉด ํŽธํ•ด
โ€ข ์ด๋ชจ์ง€ ํ™œ์šฉ: ๊ฐ์ •์„ ํ‘œํ˜„ํ•˜๋ฉด ๋” ์นœ๊ทผํ•ด์ ธ! ๐Ÿ˜Š

๐Ÿ”— ์™ธ๋ถ€ ์„œ๋น„์Šค ์—ฐ๋™ํ•˜๊ธฐ

์ฑ—๋ด‡์„ ๋” ๋˜‘๋˜‘ํ•˜๊ฒŒ ๋งŒ๋“ค๋ ค๋ฉด ์™ธ๋ถ€ API์™€ ์—ฐ๋™ํ•ด์•ผ ํ•ด! ๋‚ ์”จ, ๋‰ด์Šค, ๊ฒฐ์ œ, ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ๋“ฑ ๋‹ค์–‘ํ•œ ์„œ๋น„์Šค๋ฅผ ๋ถ™์—ฌ๋ณด์ž. ๐ŸŒ

๐ŸŒค๏ธ ๋‚ ์”จ API ์—ฐ๋™ ์˜ˆ์‹œ

# weather_chatbot.py
import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

class WeatherChatbot:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "http://api.openweathermap.org/data/2.5/weather"
    
    def get_weather(self, city):
        """๋‚ ์”จ ์ •๋ณด ๊ฐ€์ ธ์˜ค๊ธฐ"""
        try:
            params = {
                'q': city,
                'appid': self.api_key,
                'units': 'metric',  # ์„ญ์”จ ์˜จ๋„
                'lang': 'kr'        # ํ•œ๊ตญ์–ด
            }
            
            response = requests.get(self.base_url, params=params)
            data = response.json()
            
            if response.status_code == 200:
                temp = data['main']['temp']
                feels_like = data['main']['feels_like']
                description = data['weather'][0]['description']
                humidity = data['main']['humidity']
                
                message = f"๐ŸŒค๏ธ {city}์˜ ํ˜„์žฌ ๋‚ ์”จ\n\n" \
                         f"๐ŸŒก๏ธ ์˜จ๋„: {temp}ยฐC (์ฒด๊ฐ: {feels_like}ยฐC)\n" \
                         f"โ˜๏ธ ๋‚ ์”จ: {description}\n" \
                         f"๐Ÿ’ง ์Šต๋„: {humidity}%"
                
                return message
            else:
                return "์ฃ„์†กํ•ด์š”, ํ•ด๋‹น ๋„์‹œ์˜ ๋‚ ์”จ ์ •๋ณด๋ฅผ ์ฐพ์„ ์ˆ˜ ์—†์–ด์š”. ๐Ÿ˜ข"
                
        except Exception as e:
            return f"๋‚ ์”จ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ์ค‘ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์–ด์š”: {str(e)}"
    
    def process_message(self, message):
        """๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ"""
        message = message.lower()
        
        # ๋‚ ์”จ ๊ด€๋ จ ํ‚ค์›Œ๋“œ ํ™•์ธ
        weather_keywords = ['๋‚ ์”จ', 'weather', '๊ธฐ์˜จ', '์˜จ๋„']
        
        if any(keyword in message for keyword in weather_keywords):
            # ๋„์‹œ ์ด๋ฆ„ ์ถ”์ถœ (๊ฐ„๋‹จํ•œ ๋ฐฉ๋ฒ•)
            cities = ['์„œ์šธ', '๋ถ€์‚ฐ', '๋Œ€๊ตฌ', '์ธ์ฒœ', '๊ด‘์ฃผ', '๋Œ€์ „', '์šธ์‚ฐ']
            
            for city in cities:
                if city in message:
                    return self.get_weather(city)
            
            return "์–ด๋А ๋„์‹œ์˜ ๋‚ ์”จ๊ฐ€ ๊ถ๊ธˆํ•˜์‹ ๊ฐ€์š”? (์˜ˆ: ์„œ์šธ ๋‚ ์”จ)"
        
        return "๋‚ ์”จ ์ •๋ณด๋ฅผ ์›ํ•˜์‹œ๋ฉด '๋„์‹œ์ด๋ฆ„ ๋‚ ์”จ'๋ผ๊ณ  ๋ง์”€ํ•ด์ฃผ์„ธ์š”! ๐ŸŒค๏ธ"

# API ์—”๋“œํฌ์ธํŠธ
@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('message', '')
    
    # OpenWeatherMap API ํ‚ค (์‹ค์ œ๋กœ๋Š” ํ™˜๊ฒฝ๋ณ€์ˆ˜๋กœ ๊ด€๋ฆฌ)
    API_KEY = "your_api_key_here"
    
    chatbot = WeatherChatbot(API_KEY)
    response = chatbot.process_message(user_message)
    
    return jsonify({'response': response})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

๐Ÿ’ณ ๊ฒฐ์ œ ์‹œ์Šคํ…œ ์—ฐ๋™

# payment_chatbot.py
import stripe
from flask import Flask, request, jsonify

app = Flask(__name__)

# Stripe API ํ‚ค ์„ค์ •
stripe.api_key = "your_stripe_secret_key"

class PaymentChatbot:
    def __init__(self):
        self.cart = {}  # ์žฅ๋ฐ”๊ตฌ๋‹ˆ
        self.products = {
            'ํ”ผ์ž': {'name': 'ํŽ˜ํผ๋กœ๋‹ˆ ํ”ผ์ž', 'price': 15000},
            'ํŒŒ์Šคํƒ€': {'name': '๊นŒ๋ฅด๋ณด๋‚˜๋ผ ํŒŒ์Šคํƒ€', 'price': 12000},
            '์ƒ๋Ÿฌ๋“œ': {'name': '์‹œ์ € ์ƒ๋Ÿฌ๋“œ', 'price': 8000},
        }
    
    def add_to_cart(self, user_id, product_key, quantity=1):
        """์žฅ๋ฐ”๊ตฌ๋‹ˆ์— ์ถ”๊ฐ€"""
        if product_key not in self.products:
            return "์ฃ„์†กํ•ด์š”, ํ•ด๋‹น ์ƒํ’ˆ์„ ์ฐพ์„ ์ˆ˜ ์—†์–ด์š”. ๐Ÿ˜ข"
        
        if user_id not in self.cart:
            self.cart[user_id] = {}
        
        if product_key in self.cart[user_id]:
            self.cart[user_id][product_key] += quantity
        else:
            self.cart[user_id][product_key] = quantity
        
        product = self.products[product_key]
        return f"โœ… {product['name']} {quantity}๊ฐœ๊ฐ€ ์žฅ๋ฐ”๊ตฌ๋‹ˆ์— ์ถ”๊ฐ€๋˜์—ˆ์–ด์š”!"
    
    def show_cart(self, user_id):
        """์žฅ๋ฐ”๊ตฌ๋‹ˆ ๋ณด๊ธฐ"""
        if user_id not in self.cart or not self.cart[user_id]:
            return "์žฅ๋ฐ”๊ตฌ๋‹ˆ๊ฐ€ ๋น„์–ด์žˆ์–ด์š”! ๐Ÿ›’"
        
        message = "๐Ÿ›’ ์žฅ๋ฐ”๊ตฌ๋‹ˆ\n\n"
        total = 0
        
        for product_key, quantity in self.cart[user_id].items():
            product = self.products[product_key]
            subtotal = product['price'] * quantity
            total += subtotal
            
            message += f"โ€ข {product['name']} x{quantity}: {subtotal:,}์›\n"
        
        message += f"\n๐Ÿ’ฐ ์ด ๊ธˆ์•ก: {total:,}์›"
        return message
    
    def create_payment(self, user_id):
        """๊ฒฐ์ œ ์ƒ์„ฑ"""
        if user_id not in self.cart or not self.cart[user_id]:
            return {"success": False, "message": "์žฅ๋ฐ”๊ตฌ๋‹ˆ๊ฐ€ ๋น„์–ด์žˆ์–ด์š”!"}
        
        # ์ด ๊ธˆ์•ก ๊ณ„์‚ฐ
        total = 0
        items = []
        
        for product_key, quantity in self.cart[user_id].items():
            product = self.products[product_key]
            subtotal = product['price'] * quantity
            total += subtotal
            items.append({
                'name': product['name'],
                'quantity': quantity,
                'amount': product['price']
            })
        
        try:
            # Stripe ๊ฒฐ์ œ ์ธํ…ํŠธ ์ƒ์„ฑ
            payment_intent = stripe.PaymentIntent.create(
                amount=total,  # ์› ๋‹จ์œ„
                currency='krw',
                metadata={
                    'user_id': user_id,
                    'items': str(items)
                }
            )
            
            # ์žฅ๋ฐ”๊ตฌ๋‹ˆ ๋น„์šฐ๊ธฐ
            self.cart[user_id] = {}
            
            return {
                "success": True,
                "message": f"๊ฒฐ์ œ๊ฐ€ ์ƒ์„ฑ๋˜์—ˆ์–ด์š”! ๐Ÿ’ณ\n์ด {total:,}์›",
                "client_secret": payment_intent.client_secret
            }
            
        except Exception as e:
            return {
                "success": False,
                "message": f"๊ฒฐ์ œ ์ƒ์„ฑ ์ค‘ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์–ด์š”: {str(e)}"
            }

chatbot = PaymentChatbot()

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_id = data.get('user_id', 'guest')
    message = data.get('message', '').lower()
    
    # ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ
    if '์ถ”๊ฐ€' in message or '์ฃผ๋ฌธ' in message:
        for product_key in chatbot.products.keys():
            if product_key in message:
                response = chatbot.add_to_cart(user_id, product_key)
                return jsonify({'response': response})
        
        return jsonify({'response': '์–ด๋–ค ์ƒํ’ˆ์„ ์ถ”๊ฐ€ํ•˜์‹œ๊ฒ ์–ด์š”? (ํ”ผ์ž, ํŒŒ์Šคํƒ€, ์ƒ๋Ÿฌ๋“œ)'})
    
    elif '์žฅ๋ฐ”๊ตฌ๋‹ˆ' in message or '์นดํŠธ' in message:
        response = chatbot.show_cart(user_id)
        return jsonify({'response': response})
    
    elif '๊ฒฐ์ œ' in message or '๊ตฌ๋งค' in message:
        result = chatbot.create_payment(user_id)
        return jsonify(result)
    
    else:
        return jsonify({
            'response': '์ฃผ๋ฌธํ•˜์‹œ๋ ค๋ฉด "ํ”ผ์ž ์ถ”๊ฐ€", ์žฅ๋ฐ”๊ตฌ๋‹ˆ๋ฅผ ๋ณด์‹œ๋ ค๋ฉด "์žฅ๋ฐ”๊ตฌ๋‹ˆ", '
                       '๊ฒฐ์ œํ•˜์‹œ๋ ค๋ฉด "๊ฒฐ์ œ"๋ผ๊ณ  ๋ง์”€ํ•ด์ฃผ์„ธ์š”! ๐Ÿ•'
        })

if __name__ == '__main__':
    app.run(debug=True, port=5000)

โš ๏ธ ๋ณด์•ˆ ์ฃผ์˜์‚ฌํ•ญ โ€ข API ํ‚ค๋Š” ์ ˆ๋Œ€ ์ฝ”๋“œ์— ์ง์ ‘ ๋„ฃ์ง€ ๋ง๊ณ  ํ™˜๊ฒฝ๋ณ€์ˆ˜๋กœ ๊ด€๋ฆฌํ•ด
โ€ข ๊ฒฐ์ œ ์ •๋ณด๋Š” PCI DSS ๊ทœ์ •์„ ์ค€์ˆ˜ํ•ด์•ผ ํ•ด
โ€ข HTTPS๋ฅผ ๋ฐ˜๋“œ์‹œ ์‚ฌ์šฉํ•ด (์•”ํ˜ธํ™” ํ†ต์‹ )
โ€ข ์‚ฌ์šฉ์ž ์ž…๋ ฅ์€ ํ•ญ์ƒ ๊ฒ€์ฆํ•˜๊ณ  sanitizeํ•ด
โ€ข ๋ฏผ๊ฐํ•œ ์ •๋ณด๋Š” ๋กœ๊ทธ์— ๋‚จ๊ธฐ์ง€ ๋งˆ!

๐Ÿ“Š ์ฑ—๋ด‡ ์„ฑ๋Šฅ ์ธก์ •๊ณผ ๊ฐœ์„ 

์ฑ—๋ด‡์„ ๋งŒ๋“ค์—ˆ๋‹ค๊ณ  ๋์ด ์•„๋‹ˆ์•ผ! ์ง€์†์ ์œผ๋กœ ์„ฑ๋Šฅ์„ ์ธก์ •ํ•˜๊ณ  ๊ฐœ์„ ํ•ด์•ผ ํ•ด. ๋ฐ์ดํ„ฐ ๊ธฐ๋ฐ˜์œผ๋กœ ๋˜‘๋˜‘ํ•˜๊ฒŒ ๋งŒ๋“ค์–ด๊ฐ€์ž! ๐Ÿ“ˆ

๐ŸŽฏ ์ฃผ์š” ์„ฑ๋Šฅ ์ง€ํ‘œ (KPI)

1. ์ •ํ™•๋„ (Accuracy) ๐ŸŽฏ
์‚ฌ์šฉ์ž ์˜๋„๋ฅผ ์–ผ๋งˆ๋‚˜ ์ •ํ™•ํ•˜๊ฒŒ ํŒŒ์•…ํ•˜๋Š”๊ฐ€?
๋ชฉํ‘œ: 85% ์ด์ƒ

2. ์‘๋‹ต ์‹œ๊ฐ„ (Response Time) โฑ๏ธ
์งˆ๋ฌธ๋ถ€ํ„ฐ ๋‹ต๋ณ€๊นŒ์ง€ ๊ฑธ๋ฆฌ๋Š” ์‹œ๊ฐ„
๋ชฉํ‘œ: 2์ดˆ ์ด๋‚ด

3. ์™„๋ฃŒ์œจ (Completion Rate) โœ…
์‚ฌ์šฉ์ž๊ฐ€ ์›ํ•˜๋Š” ์ž‘์—…์„ ์™„๋ฃŒํ•œ ๋น„์œจ
๋ชฉํ‘œ: 70% ์ด์ƒ

4. ์‚ฌ์šฉ์ž ๋งŒ์กฑ๋„ (CSAT) ๐Ÿ˜Š
๋Œ€ํ™” ํ›„ ์‚ฌ์šฉ์ž ๋งŒ์กฑ๋„ ์ ์ˆ˜
๋ชฉํ‘œ: 4.0/5.0 ์ด์ƒ

5. ํด๋ฐฑ๋ฅ  (Fallback Rate) ๐Ÿค”
"์ดํ•ดํ•˜์ง€ ๋ชปํ–ˆ์–ด์š”" ์‘๋‹ต ๋น„์œจ
๋ชฉํ‘œ: 15% ์ดํ•˜

๐Ÿ“ˆ ๋กœ๊น… ๋ฐ ๋ถ„์„ ์‹œ์Šคํ…œ

# analytics_chatbot.py
import logging
from datetime import datetime
import json
from collections import defaultdict

class ChatbotAnalytics:
    def __init__(self):
        # ๋กœ๊น… ์„ค์ •
        logging.basicConfig(
            filename='chatbot.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        
        self.conversations = []
        self.metrics = defaultdict(int)
    
    def log_conversation(self, user_id, user_message, bot_response, 
                        intent=None, confidence=None, response_time=None):
        """๋Œ€ํ™” ๋กœ๊น…"""
        conversation = {
            'timestamp': datetime.now().isoformat(),
            'user_id': user_id,
            'user_message': user_message,
            'bot_response': bot_response,
            'intent': intent,
            'confidence': confidence,
            'response_time': response_time
        }
        
        self.conversations.append(conversation)
        
        # ํŒŒ์ผ์— ์ €์žฅ
        logging.info(json.dumps(conversation, ensure_ascii=False))
        
        # ๋ฉ”ํŠธ๋ฆญ ์—…๋ฐ์ดํŠธ
        self.metrics['total_conversations'] += 1
        if intent:
            self.metrics[f'intent_{intent}'] += 1
        if confidence and confidence < 0.5:
            self.metrics['low_confidence'] += 1
    
    def log_feedback(self, user_id, conversation_id, rating, comment=None):
        """์‚ฌ์šฉ์ž ํ”ผ๋“œ๋ฐฑ ๋กœ๊น…"""
        feedback = {
            'timestamp': datetime.now().isoformat(),
            'user_id': user_id,
            'conversation_id': conversation_id,
            'rating': rating,
            'comment': comment
        }
        
        logging.info(f"FEEDBACK: {json.dumps(feedback, ensure_ascii=False)}")
        
        self.metrics['total_feedback'] += 1
        self.metrics['rating_sum'] += rating
    
    def get_statistics(self):
        """ํ†ต๊ณ„ ์กฐํšŒ"""
        total = self.metrics['total_conversations']
        
        if total == 0:
            return "์•„์ง ๋Œ€ํ™” ๋ฐ์ดํ„ฐ๊ฐ€ ์—†์–ด์š”!"
        
        stats = {
            '์ด ๋Œ€ํ™” ์ˆ˜': total,
            '๋‚ฎ์€ ์‹ ๋ขฐ๋„ ๋น„์œจ': f"{(self.metrics['low_confidence'] / total * 100):.1f}%",
        }
        
        # ํ‰๊ท  ๋งŒ์กฑ๋„
        if self.metrics['total_feedback'] > 0:
            avg_rating = self.metrics['rating_sum'] / self.metrics['total_feedback']
            stats['ํ‰๊ท  ๋งŒ์กฑ๋„'] = f"{avg_rating:.2f}/5.0"
        
        # ์ธ๊ธฐ ์˜๋„
        intent_counts = {k: v for k, v in self.metrics.items() if k.startswith('intent_')}
        if intent_counts:
            top_intent = max(intent_counts.items(), key=lambda x: x[1])
            stats['๊ฐ€์žฅ ๋งŽ์€ ์˜๋„'] = top_intent[0].replace('intent_', '')
        
        return stats
    
    def analyze_failed_conversations(self):
        """์‹คํŒจํ•œ ๋Œ€ํ™” ๋ถ„์„"""
        failed = [
            conv for conv in self.conversations
            if conv.get('confidence', 1.0) < 0.5
        ]
        
        if not failed:
            return "์‹คํŒจํ•œ ๋Œ€ํ™”๊ฐ€ ์—†์–ด์š”! ๐ŸŽ‰"
        
        # ์‹คํŒจ ํŒจํ„ด ๋ถ„์„
        failed_messages = [conv['user_message'] for conv in failed]
        
        return {
            '์‹คํŒจ ๊ฑด์ˆ˜': len(failed),
            '์‹คํŒจ์œจ': f"{(len(failed) / len(self.conversations) * 100):.1f}%",
            '์‹คํŒจ ๋ฉ”์‹œ์ง€ ์˜ˆ์‹œ': failed_messages[:5]
        }
    
    def generate_report(self):
        """์ข…ํ•ฉ ๋ฆฌํฌํŠธ ์ƒ์„ฑ"""
        report = "=" * 50 + "\n"
        report += "๐Ÿ“Š ์ฑ—๋ด‡ ์„ฑ๋Šฅ ๋ฆฌํฌํŠธ\n"
        report += "=" * 50 + "\n\n"
        
        # ๊ธฐ๋ณธ ํ†ต๊ณ„
        stats = self.get_statistics()
        report += "๐Ÿ“ˆ ๊ธฐ๋ณธ ํ†ต๊ณ„\n"
        for key, value in stats.items():
            report += f"  โ€ข {key}: {value}\n"
        
        report += "\n"
        
        # ์‹คํŒจ ๋ถ„์„
        failed_analysis = self.analyze_failed_conversations()
        report += "โŒ ์‹คํŒจ ๋ถ„์„\n"
        if isinstance(failed_analysis, dict):
            for key, value in failed_analysis.items():
                report += f"  โ€ข {key}: {value}\n"
        else:
            report += f"  {failed_analysis}\n"
        
        report += "\n"
        
        # ๊ฐœ์„  ์ œ์•ˆ
        report += "๐Ÿ’ก ๊ฐœ์„  ์ œ์•ˆ\n"
        
        if self.metrics['low_confidence'] / self.metrics['total_conversations'] > 0.2:
            report += "  โ€ข ๋‚ฎ์€ ์‹ ๋ขฐ๋„ ๋น„์œจ์ด ๋†’์Šต๋‹ˆ๋‹ค. ํ•™์Šต ๋ฐ์ดํ„ฐ๋ฅผ ์ถ”๊ฐ€ํ•˜์„ธ์š”.\n"
        
        if self.metrics.get('total_feedback', 0) > 0:
            avg_rating = self.metrics['rating_sum'] / self.metrics['total_feedback']
            if avg_rating < 3.5:
                report += "  โ€ข ์‚ฌ์šฉ์ž ๋งŒ์กฑ๋„๊ฐ€ ๋‚ฎ์Šต๋‹ˆ๋‹ค. ์‘๋‹ต ํ’ˆ์งˆ์„ ๊ฐœ์„ ํ•˜์„ธ์š”.\n"
        
        report += "\n" + "=" * 50
        
        return report

# ์‚ฌ์šฉ ์˜ˆ์‹œ
if __name__ == "__main__":
    analytics = ChatbotAnalytics()
    
    # ๋Œ€ํ™” ๋กœ๊น…
    analytics.log_conversation(
        user_id="user123",
        user_message="์•ˆ๋…•ํ•˜์„ธ์š”",
        bot_response="์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”?",
        intent="greeting",
        confidence=0.95,
        response_time=0.3
    )
    
    analytics.log_conversation(
        user_id="user123",
        user_message="์ด๊ฑฐ ๋ญ์•ผ",
        bot_response="์ฃ„์†กํ•ด์š”, ์ดํ•ดํ•˜์ง€ ๋ชปํ–ˆ์–ด์š”.",
        intent=None,
        confidence=0.2,
        response_time=0.5
    )
    
    # ํ”ผ๋“œ๋ฐฑ ๋กœ๊น…
    analytics.log_feedback(
        user_id="user123",
        conversation_id="conv001",
        rating=4,
        comment="๋„์›€์ด ๋˜์—ˆ์–ด์š”!"
    )
    
    # ๋ฆฌํฌํŠธ ์ƒ์„ฑ
    print(analytics.generate_report())

๐Ÿ’ก A/B ํ…Œ์ŠคํŒ… ๋‘ ๊ฐ€์ง€ ๋ฒ„์ „์˜ ์‘๋‹ต์„ ๋งŒ๋“ค์–ด์„œ ์–ด๋А ๊ฒŒ ๋” ํšจ๊ณผ์ ์ธ์ง€ ํ…Œ์ŠคํŠธํ•ด๋ด! ์˜ˆ๋ฅผ ๋“ค์–ด:
โ€ข ๋ฒ„์ „ A: "์•ˆ๋…•ํ•˜์„ธ์š”! ๋ฌด์—‡์„ ๋„์™€๋“œ๋ฆด๊นŒ์š”?"
โ€ข ๋ฒ„์ „ B: "๋ฐ˜๊ฐ‘์Šต๋‹ˆ๋‹ค! ๊ถ๊ธˆํ•œ ์ ์ด ์žˆ์œผ์‹ ๊ฐ€์š”?"

์‚ฌ์šฉ์ž ๋ฐ˜์‘์„ ์ธก์ •ํ•ด์„œ ๋” ๋‚˜์€ ๋ฒ„์ „์„ ์„ ํƒํ•˜๋ฉด ๋ผ! ๐Ÿ“Š

๐Ÿš€ ์ฑ—๋ด‡ ๋ฐฐํฌํ•˜๊ธฐ

๋กœ์ปฌ์—์„œ๋งŒ ๋Œ์•„๊ฐ€๋Š” ์ฑ—๋ด‡์€ ์˜๋ฏธ๊ฐ€ ์—†์ง€! ์‹ค์ œ ์‚ฌ์šฉ์ž๋“ค์ด ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋„๋ก ๋ฐฐํฌํ•ด๋ณด์ž. โ˜๏ธ

๐Ÿณ Docker๋กœ ์ปจํ…Œ์ด๋„ˆํ™”

# Dockerfile
FROM python:3.9-slim

# ์ž‘์—… ๋””๋ ‰ํ† ๋ฆฌ ์„ค์ •
WORKDIR /app

# ์˜์กด์„ฑ ํŒŒ์ผ ๋ณต์‚ฌ
COPY requirements.txt .

# ์˜์กด์„ฑ ์„ค์น˜
RUN pip install --no-cache-dir -r requirements.txt

# ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ํŒŒ์ผ ๋ณต์‚ฌ
COPY . .

# ํฌํŠธ ๋…ธ์ถœ
EXPOSE 5000

# ํ™˜๊ฒฝ๋ณ€์ˆ˜ ์„ค์ •
ENV FLASK_APP=app.py
ENV FLASK_ENV=production

# ์‹คํ–‰ ๋ช…๋ น
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "app:app"]
# requirements.txt
flask==2.3.0
gunicorn==20.1.0
nltk==3.8.1
tensorflow==2.12.0
scikit-learn==1.2.2
requests==2.31.0
python-dotenv==1.0.0
# docker-compose.yml
version: '3.8'

services:
  chatbot:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/chatbot
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    restart: always
  
  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=chatbot
    volumes:
      - postgres_data:/var/lib/postgresql/data
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:
# ๋นŒ๋“œ ๋ฐ ์‹คํ–‰
docker-compose build
docker-compose up -d

# ๋กœ๊ทธ ํ™•์ธ
docker-compose logs -f chatbot

# ์ค‘์ง€
docker-compose down

โ˜๏ธ ํด๋ผ์šฐ๋“œ ๋ฐฐํฌ (AWS, GCP, Azure)

๐ŸŒ ๋ฐฐํฌ ์˜ต์…˜ ๋น„๊ต

AWS (Amazon Web Services)
โ€ข EC2: ๊ฐ€์ƒ ์„œ๋ฒ„์— ์ง์ ‘ ๋ฐฐํฌ
โ€ข Lambda: ์„œ๋ฒ„๋ฆฌ์Šค๋กœ ๋น„์šฉ ์ ˆ๊ฐ
โ€ข ECS/EKS: ์ปจํ…Œ์ด๋„ˆ ์˜ค์ผ€์ŠคํŠธ๋ ˆ์ด์…˜
โ€ข Lex: AWS์˜ ์ฑ—๋ด‡ ์ „์šฉ ์„œ๋น„์Šค

GCP (Google Cloud Platform)
โ€ข Compute Engine: VM ์ธ์Šคํ„ด์Šค
โ€ข Cloud Run: ์ปจํ…Œ์ด๋„ˆ ์ž๋™ ์Šค์ผ€์ผ๋ง
โ€ข Dialogflow: ๊ตฌ๊ธ€์˜ ์ฑ—๋ด‡ ํ”Œ๋žซํผ
โ€ข Vertex AI: ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ ๋ฐฐํฌ

Azure (Microsoft)
โ€ข Virtual Machines: VM ๋ฐฐํฌ
โ€ข App Service: PaaS ํ”Œ๋žซํผ
โ€ข Bot Service: ์ฑ—๋ด‡ ์ „์šฉ ์„œ๋น„์Šค
โ€ข Cognitive Services: AI ์„œ๋น„์Šค

๐Ÿ”ง Heroku ๊ฐ„๋‹จ ๋ฐฐํฌ

# Procfile
web: gunicorn app:app
# runtime.txt
python-3.9.16
# Heroku ๋ฐฐํฌ ๋ช…๋ น์–ด
# Heroku CLI ์„ค์น˜ ํ›„

# ๋กœ๊ทธ์ธ
heroku login

# ์•ฑ ์ƒ์„ฑ
heroku create my-chatbot-app

# Git ์ €์žฅ์†Œ ์—ฐ๊ฒฐ
git init
git add .
git commit -m "Initial commit"

# Heroku์— ํ‘ธ์‹œ
git push heroku main

# ๋กœ๊ทธ ํ™•์ธ
heroku logs --tail

# ์•ฑ ์—ด๊ธฐ
heroku open

๐ŸŽ“ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ ํ•™์Šต ๋กœ๋“œ๋งต

์ฑ—๋ด‡ ๊ฐœ๋ฐœ์ž๊ฐ€ ๋˜๊ณ  ์‹ถ๋‹ค๋ฉด? ์ด ๋กœ๋“œ๋งต์„ ๋”ฐ๋ผ๊ฐ€๋ด! ๋‹จ๊ณ„๋ณ„๋กœ ์ฐจ๊ทผ์ฐจ๊ทผ ์„ฑ์žฅํ•  ์ˆ˜ ์žˆ์–ด. ๐ŸŒฑ

1 ๊ธฐ์ดˆ Python ๊ธฐ๋ณธ ์›น ๊ฐœ๋ฐœ ๊ธฐ์ดˆ 2 NLP ์ž์—ฐ์–ด ์ฒ˜๋ฆฌ ํ…์ŠคํŠธ ๋ถ„์„ 3 ML ๋จธ์‹ ๋Ÿฌ๋‹ ์˜๋„ ๋ถ„๋ฅ˜ 4 DL ๋”ฅ๋Ÿฌ๋‹ Transformer 5 ์‹ค์ „ ํ”„๋กœ์ ํŠธ ๋ฐฐํฌ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ์ž ๋กœ๋“œ๋งต ๊ฐ ๋‹จ๊ณ„๋งˆ๋‹ค 3-6๊ฐœ์›” ํˆฌ์žํ•˜๋ฉด ์ „๋ฌธ๊ฐ€๊ฐ€ ๋  ์ˆ˜ ์žˆ์–ด์š”! ๐Ÿš€

1๋‹จ๊ณ„: ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ธฐ์ดˆ (3๊ฐœ์›”) ๐Ÿ“š

โ€ข Python ๋ฌธ๋ฒ• ์™„๋ฒฝ ๋งˆ์Šคํ„ฐ
โ€ข Flask/Django ์›น ํ”„๋ ˆ์ž„์›Œํฌ
โ€ข Git/GitHub ๋ฒ„์ „ ๊ด€๋ฆฌ
โ€ข REST API ์ดํ•ด
โ€ข ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ๊ธฐ์ดˆ (SQL)

2๋‹จ๊ณ„: ์ž์—ฐ์–ด ์ฒ˜๋ฆฌ (4๊ฐœ์›”) ๐Ÿ”ค

โ€ข NLTK, spaCy ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
โ€ข ํ† ํฐํ™”, ํ˜•ํƒœ์†Œ ๋ถ„์„
โ€ข TF-IDF, Word2Vec
โ€ข ๊ฐ์ • ๋ถ„์„, ๊ฐœ์ฒด๋ช… ์ธ์‹
โ€ข ํ•œ๊ตญ์–ด NLP (KoNLPy)

3๋‹จ๊ณ„: ๋จธ์‹ ๋Ÿฌ๋‹ (4๊ฐœ์›”) ๐Ÿค–

โ€ข Scikit-learn ๋งˆ์Šคํ„ฐ
โ€ข ๋ถ„๋ฅ˜, ํšŒ๊ท€, ํด๋Ÿฌ์Šคํ„ฐ๋ง
โ€ข ์˜๋„ ๋ถ„๋ฅ˜ ๋ชจ๋ธ ๊ตฌ์ถ•
โ€ข ๋ชจ๋ธ ํ‰๊ฐ€ ๋ฐ ํŠœ๋‹
โ€ข ์‹ค์ „ ํ”„๋กœ์ ํŠธ (๊ฐ„๋‹จํ•œ ์ฑ—๋ด‡)

4๋‹จ๊ณ„: ๋”ฅ๋Ÿฌ๋‹ (6๊ฐœ์›”) ๐Ÿง 

โ€ข TensorFlow/PyTorch
โ€ข RNN, LSTM, GRU
โ€ข Seq2Seq, Attention
โ€ข Transformer, BERT
โ€ข ํŒŒ์ธํŠœ๋‹ ๊ธฐ๋ฒ•

5๋‹จ๊ณ„: ์‹ค์ „ ๋ฐฐํฌ (3๊ฐœ์›”) ๐Ÿš€

โ€ข Docker ์ปจํ…Œ์ด๋„ˆํ™”
โ€ข ํด๋ผ์šฐ๋“œ ๋ฐฐํฌ (AWS/GCP)
โ€ข CI/CD ํŒŒ์ดํ”„๋ผ์ธ
โ€ข ๋ชจ๋‹ˆํ„ฐ๋ง ๋ฐ ๋กœ๊น…
โ€ข ํฌํŠธํด๋ฆฌ์˜ค ๊ตฌ์ถ•

๐Ÿ’ก ํ•™์Šต ํŒ โ€ข ์ด๋ก ๋งŒ ๊ณต๋ถ€ํ•˜์ง€ ๋ง๊ณ  ์ง์ ‘ ๋งŒ๋“ค์–ด๋ด!
โ€ข ์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ํ‚ค์›Œ๊ฐ€
โ€ข GitHub์— ์ฝ”๋“œ๋ฅผ ๊ณต์œ ํ•˜๊ณ  ํ”ผ๋“œ๋ฐฑ ๋ฐ›์•„
โ€ข ์˜จ๋ผ์ธ ์ปค๋ฎค๋‹ˆํ‹ฐ์— ์ฐธ์—ฌํ•ด (Reddit, Stack Overflow)
โ€ข ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์‹ค์ „ ๊ฒฝํ—˜ ์Œ“๊ธฐ!

๐ŸŒŸ ์ตœ์‹  ํŠธ๋ Œ๋“œ: GPT์™€ LLM ํ™œ์šฉ

2023๋…„ ์ดํ›„ ์ฑ—๋ด‡์˜ ํŒ๋„๋ฅผ ๋ฐ”๊พผ ๊ฑด ๋ฐ”๋กœ GPT ๊ฐ™์€ ๋Œ€๊ทœ๋ชจ ์–ธ์–ด ๋ชจ๋ธ(LLM)์ด์•ผ! OpenAI API๋ฅผ ํ™œ์šฉํ•˜๋ฉด ํ›จ์”ฌ ๋˜‘๋˜‘ํ•œ ์ฑ—๋ด‡์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ๐Ÿ”ฅ

๐Ÿค– OpenAI API ํ™œ์šฉํ•˜๊ธฐ

# gpt_chatbot.py
import openai
from flask import Flask, request, jsonify
import os

app = Flask(__name__)

# OpenAI API ํ‚ค ์„ค์ •
openai.api_key = os.getenv("OPENAI_API_KEY")

class GPTChatbot:
    def __init__(self, system_prompt=None):
        self.system_prompt = system_prompt or """
        ๋‹น์‹ ์€ ์นœ์ ˆํ•˜๊ณ  ๋„์›€์ด ๋˜๋Š” AI ์–ด์‹œ์Šคํ„ดํŠธ์ž…๋‹ˆ๋‹ค.
        ์‚ฌ์šฉ์ž์˜ ์งˆ๋ฌธ์— ์ •ํ™•ํ•˜๊ณ  ์œ ์šฉํ•œ ๋‹ต๋ณ€์„ ์ œ๊ณตํ•˜์„ธ์š”.
        ํ•œ๊ตญ์–ด๋กœ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ๋Œ€ํ™”ํ•˜์„ธ์š”.
        """
        
        self.conversation_history = []
    
    def chat(self, user_message):
        """GPT์™€ ๋Œ€ํ™”"""
        try:
            # ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
            self.conversation_history.append({
                "role": "user",
                "content": user_message
            })
            
            # GPT API ํ˜ธ์ถœ
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",  # ๋˜๋Š” gpt-4
                messages=[
                    {"role": "system", "content": self.system_prompt}
                ] + self.conversation_history,
                temperature=0.7,
                max_tokens=500
            )
            
            # ์‘๋‹ต ์ถ”์ถœ
            bot_message = response.choices[0].message.content
            
            # ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ์— ์ถ”๊ฐ€
            self.conversation_history.append({
                "role": "assistant",
                "content": bot_message
            })
            
            # ํžˆ์Šคํ† ๋ฆฌ๊ฐ€ ๋„ˆ๋ฌด ๊ธธ์–ด์ง€๋ฉด ์˜ค๋ž˜๋œ ๊ฒƒ ์ œ๊ฑฐ
            if len(self.conversation_history) > 20:
                self.conversation_history = self.conversation_history[-20:]
            
            return bot_message
            
        except Exception as e:
            return f"์ฃ„์†กํ•ด์š”, ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์–ด์š”: {str(e)}"
    
    def reset_conversation(self):
        """๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ์ดˆ๊ธฐํ™”"""
        self.conversation_history = []

# ํŠนํ™”๋œ ์ฑ—๋ด‡ ์˜ˆ์‹œ
class CustomerServiceBot(GPTChatbot):
    def __init__(self):
        system_prompt = """
        ๋‹น์‹ ์€ ์ „๋ฌธ์ ์ธ ๊ณ ๊ฐ ์„œ๋น„์Šค ๋‹ด๋‹น์ž์ž…๋‹ˆ๋‹ค.
        
        ์—ญํ• :
        - ๊ณ ๊ฐ์˜ ๋ฌธ์˜์‚ฌํ•ญ์— ์นœ์ ˆํ•˜๊ณ  ์ •ํ™•ํ•˜๊ฒŒ ๋‹ต๋ณ€
        - ์ œํ’ˆ ์ •๋ณด, ๋ฐฐ์†ก, ๋ฐ˜ํ’ˆ/๊ตํ™˜ ๊ด€๋ จ ๋„์›€ ์ œ๊ณต
        - ๋ถˆ๋งŒ ์‚ฌํ•ญ์€ ๊ณต๊ฐํ•˜๋ฉฐ ํ•ด๊ฒฐ์ฑ… ์ œ์‹œ
        - ํ•ญ์ƒ ์กด๋Œ“๋ง ์‚ฌ์šฉ
        
        ์ œํ’ˆ ์ •๋ณด:
        - ํ”ผ์ž: 15,000์› (ํŽ˜ํผ๋กœ๋‹ˆ, ๋งˆ๋ฅด๊ฒŒ๋ฆฌํƒ€, ํ•˜์™€์ด์•ˆ)
        - ๋ฐฐ์†ก: ์ฃผ๋ฌธ ํ›„ 30-40๋ถ„ ์†Œ์š”
        - ๋ฐ˜ํ’ˆ: ๋ฐฐ์†ก ํ›„ 1์‹œ๊ฐ„ ์ด๋‚ด ๊ฐ€๋Šฅ
        
        ๋‹ต๋ณ€ ํ˜•์‹:
        1. ๊ณ ๊ฐ ๋ฌธ์˜ ํ™•์ธ
        2. ๋ช…ํ™•ํ•œ ๋‹ต๋ณ€ ์ œ๊ณต
        3. ์ถ”๊ฐ€ ๋„์›€ ์ œ์•ˆ
        """
        super().__init__(system_prompt)

# API ์—”๋“œํฌ์ธํŠธ
chatbot = CustomerServiceBot()

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('message', '')
    
    if not user_message:
        return jsonify({'error': '๋ฉ”์‹œ์ง€๋ฅผ ์ž…๋ ฅํ•ด์ฃผ์„ธ์š”'}), 400
    
    response = chatbot.chat(user_message)
    
    return jsonify({
        'response': response,
        'conversation_length': len(chatbot.conversation_history)
    })

@app.route('/reset', methods=['POST'])
def reset():
    chatbot.reset_conversation()
    return jsonify({'message': '๋Œ€ํ™”๊ฐ€ ์ดˆ๊ธฐํ™”๋˜์—ˆ์Šต๋‹ˆ๋‹ค'})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

๐ŸŽจ Function Calling์œผ๋กœ ๊ธฐ๋Šฅ ํ™•์žฅ

# function_calling_bot.py
import openai
import json

class FunctionCallingBot:
    def __init__(self):
        self.functions = [
            {
                "name": "get_weather",
                "description": "ํŠน์ • ๋„์‹œ์˜ ํ˜„์žฌ ๋‚ ์”จ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "๋„์‹œ ์ด๋ฆ„ (์˜ˆ: ์„œ์šธ, ๋ถ€์‚ฐ)"
                        }
                    },
                    "required": ["city"]
                }
            },
            {
                "name": "calculate_delivery_time",
                "description": "์ฃผ๋ฌธ๋ถ€ํ„ฐ ๋ฐฐ๋‹ฌ๊นŒ์ง€ ์˜ˆ์ƒ ์‹œ๊ฐ„์„ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "distance": {
                            "type": "number",
                            "description": "๋ฐฐ๋‹ฌ ๊ฑฐ๋ฆฌ (km)"
                        },
                        "traffic": {
                            "type": "string",
                            "enum": ["์›ํ™œ", "๋ณดํ†ต", "ํ˜ผ์žก"],
                            "description": "๊ตํ†ต ์ƒํ™ฉ"
                        }
                    },
                    "required": ["distance"]
                }
            }
        ]
    
    def get_weather(self, city):
        """๋‚ ์”จ ์ •๋ณด ๊ฐ€์ ธ์˜ค๊ธฐ (์‹ค์ œ๋กœ๋Š” API ํ˜ธ์ถœ)"""
        # ๋ฐ๋ชจ์šฉ ๋”๋ฏธ ๋ฐ์ดํ„ฐ
        weather_data = {
            "์„œ์šธ": {"temp": 15, "condition": "๋ง‘์Œ"},
            "๋ถ€์‚ฐ": {"temp": 18, "condition": "ํ๋ฆผ"},
            "๋Œ€๊ตฌ": {"temp": 16, "condition": "๋น„"}
        }
        
        data = weather_data.get(city, {"temp": 20, "condition": "์•Œ ์ˆ˜ ์—†์Œ"})
        return f"{city}์˜ ํ˜„์žฌ ๋‚ ์”จ๋Š” {data['condition']}์ด๋ฉฐ, ๊ธฐ์˜จ์€ {data['temp']}ยฐC์ž…๋‹ˆ๋‹ค."
    
    def calculate_delivery_time(self, distance, traffic="๋ณดํ†ต"):
        """๋ฐฐ๋‹ฌ ์‹œ๊ฐ„ ๊ณ„์‚ฐ"""
        base_time = distance * 3  # ๊ธฐ๋ณธ: km๋‹น 3๋ถ„
        
        traffic_multiplier = {
            "์›ํ™œ": 0.8,
            "๋ณดํ†ต": 1.0,
            "ํ˜ผ์žก": 1.5
        }
        
        total_time = int(base_time * traffic_multiplier.get(traffic, 1.0))
        return f"์˜ˆ์ƒ ๋ฐฐ๋‹ฌ ์‹œ๊ฐ„์€ ์•ฝ {total_time}๋ถ„์ž…๋‹ˆ๋‹ค."
    
    def chat(self, user_message):
        """Function Calling์„ ํ™œ์šฉํ•œ ๋Œ€ํ™”"""
        try:
            # GPT API ํ˜ธ์ถœ
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "๋‹น์‹ ์€ ๋„์›€์ด ๋˜๋Š” AI ์–ด์‹œ์Šคํ„ดํŠธ์ž…๋‹ˆ๋‹ค."},
                    {"role": "user", "content": user_message}
                ],
                functions=self.functions,
                function_call="auto"
            )
            
            message = response.choices[0].message
            
            # Function Call์ด ์žˆ๋Š”์ง€ ํ™•์ธ
            if message.get("function_call"):
                function_name = message["function_call"]["name"]
                function_args = json.loads(message["function_call"]["arguments"])
                
                # ํ•จ์ˆ˜ ์‹คํ–‰
                if function_name == "get_weather":
                    function_response = self.get_weather(**function_args)
                elif function_name == "calculate_delivery_time":
                    function_response = self.calculate_delivery_time(**function_args)
                else:
                    function_response = "์ง€์›ํ•˜์ง€ ์•Š๋Š” ๊ธฐ๋Šฅ์ž…๋‹ˆ๋‹ค."
                
                # ํ•จ์ˆ˜ ๊ฒฐ๊ณผ๋ฅผ ํฌํ•จํ•ด์„œ ๋‹ค์‹œ GPT ํ˜ธ์ถœ
                second_response = openai.ChatCompletion.create(
                    model="gpt-3.5-turbo",
                    messages=[
                        {"role": "system", "content": "๋‹น์‹ ์€ ๋„์›€์ด ๋˜๋Š” AI ์–ด์‹œ์Šคํ„ดํŠธ์ž…๋‹ˆ๋‹ค."},
                        {"role": "user", "content": user_message},
                        message,
                        {
                            "role": "function",
                            "name": function_name,
                            "content": function_response
                        }
                    ]
                )
                
                return second_response.choices[0].message.content
            
            else:
                # ์ผ๋ฐ˜ ์‘๋‹ต
                return message.content
                
        except Exception as e:
            return f"์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ–ˆ์–ด์š”: {str(e)}"

# ์‚ฌ์šฉ ์˜ˆ์‹œ
if __name__ == "__main__":
    bot = FunctionCallingBot()
    
    print("Function Calling Bot: ์•ˆ๋…•ํ•˜์„ธ์š”! ๋‚ ์”จ๋‚˜ ๋ฐฐ๋‹ฌ ์‹œ๊ฐ„์„ ๋ฌผ์–ด๋ณด์„ธ์š”!")
    print("-" * 60)
    
    # ํ…Œ์ŠคํŠธ
    test_messages = [
        "์„œ์šธ ๋‚ ์”จ ์–ด๋•Œ?",
        "5km ๊ฑฐ๋ฆฌ ๋ฐฐ๋‹ฌ ์‹œ๊ฐ„ ์•Œ๋ ค์ค˜",
        "๊ตํ†ต์ด ํ˜ผ์žกํ•œ๋ฐ 10km ๋ฐฐ๋‹ฌ ์–ผ๋งˆ๋‚˜ ๊ฑธ๋ ค?"
    ]
    
    for msg in test_messages:
        print(f"\n์‚ฌ์šฉ์ž: {msg}")
        response = bot.chat(msg)
        print(f"๋ด‡: {response}")

๐ŸŽฏ LLM ํ™œ์šฉ์˜ ์žฅ๋‹จ์ 

์žฅ์  โœ…
โ€ข ์ž์—ฐ์Šค๋Ÿฌ์šด ๋Œ€ํ™” ๊ฐ€๋Šฅ
โ€ข ๋ณต์žกํ•œ ๋ฌธ๋งฅ ์ดํ•ด
โ€ข ๋‹ค์–‘ํ•œ ์ฃผ์ œ ๋Œ€์‘
โ€ข ๋น ๋ฅธ ๊ฐœ๋ฐœ ์†๋„
โ€ข ์ง€์†์ ์ธ ์„ฑ๋Šฅ ๊ฐœ์„ 

๋‹จ์  โŒ
โ€ข API ๋น„์šฉ ๋ฐœ์ƒ
โ€ข ์‘๋‹ต ์‹œ๊ฐ„ (๋„คํŠธ์›Œํฌ ์ง€์—ฐ)
โ€ข ํ• ๋ฃจ์‹œ๋„ค์ด์…˜ (์ž˜๋ชป๋œ ์ •๋ณด)
โ€ข ๋ฐ์ดํ„ฐ ํ”„๋ผ์ด๋ฒ„์‹œ ์ด์Šˆ
โ€ข ์ธํ„ฐ๋„ท ์—ฐ๊ฒฐ ํ•„์ˆ˜

โš ๏ธ ๋น„์šฉ ๊ด€๋ฆฌ ํŒ GPT API๋Š” ํ† ํฐ ๋‹จ์œ„๋กœ ๊ณผ๊ธˆ๋ผ. ๋น„์šฉ์„ ์ ˆ์•ฝํ•˜๋ ค๋ฉด:
โ€ข ๋Œ€ํ™” ํžˆ์Šคํ† ๋ฆฌ ๊ธธ์ด ์ œํ•œ
โ€ข ์บ์‹ฑ ํ™œ์šฉ (๊ฐ™์€ ์งˆ๋ฌธ์€ ์ €์žฅ๋œ ๋‹ต๋ณ€ ์‚ฌ์šฉ)
โ€ข ๊ฐ„๋‹จํ•œ ์งˆ๋ฌธ์€ ๊ทœ์น™ ๊ธฐ๋ฐ˜์œผ๋กœ ์ฒ˜๋ฆฌ
โ€ข ์›” ์‚ฌ์šฉ๋Ÿ‰ ๋ชจ๋‹ˆํ„ฐ๋ง ๋ฐ ์•Œ๋ฆผ ์„ค์ •

๐Ÿ’ผ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ์•„์ด๋””์–ด

์ด๋ก ์€ ์ถฉ๋ถ„ํžˆ ๋ฐฐ์› ์–ด! ์ด์ œ ์‹ค์ „ ํ”„๋กœ์ ํŠธ๋กœ ํฌํŠธํด๋ฆฌ์˜ค๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž. ์žฌ๋Šฅ๋„ท์—์„œ๋„ ์ด๋Ÿฐ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ’ช

๐Ÿ• 1. ์Œ์‹ ์ฃผ๋ฌธ ์ฑ—๋ด‡

๋‚œ์ด๋„: โญโญโญ
๊ธฐ๋Šฅ:
โ€ข ๋ฉ”๋‰ด ์ถ”์ฒœ ๋ฐ ์ฃผ๋ฌธ
โ€ข ์žฅ๋ฐ”๊ตฌ๋‹ˆ ๊ด€๋ฆฌ
โ€ข ๊ฒฐ์ œ ์—ฐ๋™
โ€ข ๋ฐฐ์†ก ์ถ”์ 
โ€ข ๋ฆฌ๋ทฐ ์ˆ˜์ง‘

๊ธฐ์ˆ  ์Šคํƒ: Flask, SQLite, Stripe API, Kakao Map API

๐Ÿฅ 2. ์˜๋ฃŒ ์ƒ๋‹ด ์ฑ—๋ด‡

๋‚œ์ด๋„: โญโญโญโญ
๊ธฐ๋Šฅ:
โ€ข ์ฆ์ƒ ์ฒดํฌ
โ€ข ๋ณ‘์› ์ถ”์ฒœ
โ€ข ์˜ˆ์•ฝ ๋„์›€
โ€ข ๊ฑด๊ฐ• ์ •๋ณด ์ œ๊ณต
โ€ข ์‘๊ธ‰ ์ƒํ™ฉ ๋Œ€์‘

๊ธฐ์ˆ  ์Šคํƒ: Rasa, Medical NLP, PostgreSQL

์ฃผ์˜: ์˜๋ฃŒ ์ •๋ณด๋Š” ๋ฐ˜๋“œ์‹œ ์ „๋ฌธ๊ฐ€ ๊ฒ€์ฆ ํ•„์š”!

๐Ÿ“š 3. ํ•™์Šต ๋„์šฐ๋ฏธ ์ฑ—๋ด‡

๋‚œ์ด๋„: โญโญโญโญ
๊ธฐ๋Šฅ:
โ€ข ์งˆ๋ฌธ ๋‹ต๋ณ€
โ€ข ๊ฐœ๋… ์„ค๋ช…
โ€ข ํ€ด์ฆˆ ์ƒ์„ฑ
โ€ข ํ•™์Šต ์ง„๋„ ๊ด€๋ฆฌ
โ€ข ๋งž์ถค ํ•™์Šต ์ถ”์ฒœ

๊ธฐ์ˆ  ์Šคํƒ: GPT-4, LangChain, Vector DB

๐Ÿ’ฐ 4. ๊ธˆ์œต ์ƒ๋‹ด ์ฑ—๋ด‡

๋‚œ์ด๋„: โญโญโญโญโญ
๊ธฐ๋Šฅ:
โ€ข ์˜ˆ์‚ฐ ๊ด€๋ฆฌ
โ€ข ํˆฌ์ž ์กฐ์–ธ
โ€ข ๋Œ€์ถœ ์ƒ๋‹ด
โ€ข ํ™˜์œจ ์ •๋ณด
โ€ข ๊ธˆ์œต ์ƒํ’ˆ ๋น„๊ต

๊ธฐ์ˆ  ์Šคํƒ: Django, Celery, Redis, Financial APIs

์ฃผ์˜: ๊ธˆ์œต ๊ทœ์ œ ์ค€์ˆ˜ ํ•„์ˆ˜!

๐ŸŽฎ 5. ๊ฒŒ์ž„ NPC ์ฑ—๋ด‡

๋‚œ์ด๋„: โญโญโญ
๊ธฐ๋Šฅ:
โ€ข ์บ๋ฆญํ„ฐ๋ณ„ ์„ฑ๊ฒฉ ๊ตฌํ˜„
โ€ข ํ€˜์ŠคํŠธ ์•ˆ๋‚ด
โ€ข ์Šคํ† ๋ฆฌ ์ง„ํ–‰
โ€ข ์•„์ดํ…œ ๊ฑฐ๋ž˜
โ€ข ํžŒํŠธ ์ œ๊ณต

๊ธฐ์ˆ  ์Šคํƒ: Unity, GPT API, WebSocket

๐Ÿ’ก ํ”„๋กœ์ ํŠธ ์„ฑ๊ณต ํŒ โ€ข ์ž‘๊ฒŒ ์‹œ์ž‘ํ•ด์„œ ์ ์ง„์ ์œผ๋กœ ํ™•์žฅ
โ€ข ์‚ฌ์šฉ์ž ํ”ผ๋“œ๋ฐฑ์„ ์ ๊ทน ๋ฐ˜์˜
โ€ข ๋ฌธ์„œํ™”๋ฅผ ์ฒ ์ €ํžˆ (README, API ๋ฌธ์„œ)
โ€ข GitHub์— ์˜คํ”ˆ์†Œ์Šค๋กœ ๊ณต๊ฐœ
โ€ข ๋ธ”๋กœ๊ทธ์— ๊ฐœ๋ฐœ ๊ณผ์ • ๊ธฐ๋ก
โ€ข ์žฌ๋Šฅ๋„ท์—์„œ ์‹ค์ œ ์˜๋ขฐ ๋ฐ›์•„๋ณด๊ธฐ!

๐ŸŽฏ ๋งˆ๋ฌด๋ฆฌ: ์ฑ—๋ด‡ ๊ฐœ๋ฐœ์ž๋กœ ์„ฑ์žฅํ•˜๊ธฐ

์™€! ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์—ˆ๋‹ค๋ฉด ์ด๋ฏธ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ์˜ A to Z๋ฅผ ํ›‘์€ ๊ฑฐ์•ผ. ์ถ•ํ•˜ํ•ด! ๐ŸŽ‰

์ฑ—๋ด‡ ๊ฐœ๋ฐœ์€ ๋‹จ์ˆœํžˆ ์ฝ”๋“œ๋ฅผ ์งœ๋Š” ๊ฒŒ ์•„๋‹ˆ์•ผ. ์‚ฌ์šฉ์ž๋ฅผ ์ดํ•ดํ•˜๊ณ , ๋Œ€ํ™”๋ฅผ ๋””์ž์ธํ•˜๊ณ , ๊ธฐ์ˆ ์„ ์œตํ•ฉํ•˜๋Š” ์ข…ํ•ฉ ์˜ˆ์ˆ ์ด์ง€. ์ฒ˜์Œ์—” ์–ด๋ ต๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์ง€๋งŒ, ํ•˜๋‚˜์”ฉ ๋งŒ๋“ค๋‹ค ๋ณด๋ฉด ์–ด๋А์ƒˆ ์ „๋ฌธ๊ฐ€๊ฐ€ ๋˜์–ด ์žˆ์„ ๊ฑฐ์•ผ! ๐Ÿ’ช

๊ธฐ์–ตํ•ด! ์™„๋ฒฝํ•œ ์ฑ—๋ด‡์€ ์—†์–ด. ์ง€์†์ ์œผ๋กœ ๊ฐœ์„ ํ•˜๊ณ , ์‚ฌ์šฉ์ž ํ”ผ๋“œ๋ฐฑ์„ ๋“ฃ๊ณ , ์ƒˆ๋กœ์šด ๊ธฐ์ˆ ์„ ๋ฐฐ์šฐ๋Š” ๊ฒŒ ์ค‘์š”ํ•ด. ๊ทธ๋ฆฌ๊ณ  ํ˜ผ์ž ํ•˜๊ธฐ ํž˜๋“ค ๋• ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ๋‹ค๋ฅธ ๊ฐœ๋ฐœ์ž๋“ค๊ณผ ํ˜‘์—…ํ•˜๊ฑฐ๋‚˜ ๋ฉ˜ํ† ๋ง์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ! ๐Ÿค

์ž, ์ด์ œ ๋‹น์‹ ์˜ ์ฒซ ์ฑ—๋ด‡์„ ๋งŒ๋“ค์–ด๋ณผ ์‹œ๊ฐ„์ด์•ผ! ์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ, ์ ์  ๋” ๋ณต์žกํ•˜๊ณ  ๋˜‘๋˜‘ํ•œ ์ฑ—๋ด‡์œผ๋กœ ๋ฐœ์ „์‹œ์ผœ ๋‚˜๊ฐ€๋ด. ์–ธ์  ๊ฐ€ ๋‹น์‹ ์ด ๋งŒ๋“  ์ฑ—๋ด‡์ด ์ˆ˜๋ฐฑ๋งŒ ๋ช…์˜ ์‚ฌ์šฉ์ž์™€ ๋Œ€ํ™”ํ•˜๋Š” ๋‚ ์ด ์˜ฌ ๊ฑฐ์•ผ! ๐Ÿš€

ํ–‰์šด์„ ๋นŒ์–ด! ๊ทธ๋ฆฌ๊ณ  ๊ถ๊ธˆํ•œ ๊ฒŒ ์žˆ์œผ๋ฉด ์–ธ์ œ๋“  ๋ฌผ์–ด๋ด. ์šฐ๋ฆฌ ๋ชจ๋‘ ํ•จ๊ป˜ ์„ฑ์žฅํ•˜๋Š” ๊ฐœ๋ฐœ์ž ์ปค๋ฎค๋‹ˆํ‹ฐ๋‹ˆ๊นŒ! ๐Ÿ˜Š

๐ŸŽ“ ์ฑ—๋ด‡ ๊ฐœ๋ฐœ, ์ด์ œ ์‹œ์ž‘์ด์•ผ!

์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ
์„ธ์ƒ์„ ๋ฐ”๊พธ๋Š” AI ์ฑ—๋ด‡์„ ๋งŒ๋“ค์–ด๋ณด์ž!

๐Ÿ’ป Happy Coding! ๐Ÿค–

์ด ๊ธ€์ด ๋„์›€์ด ๋˜์—ˆ๋‹ค๋ฉด, ์žฌ๋Šฅ๋„ท์—์„œ ๋” ๋งŽ์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ง€์‹์„ ํƒํ—˜ํ•ด๋ณด์„ธ์š”!
์ฑ—๋ด‡ ๊ฐœ๋ฐœ๋ถ€ํ„ฐ ์›น/์•ฑ ๊ฐœ๋ฐœ๊นŒ์ง€, ๋‹ค์–‘ํ•œ ์žฌ๋Šฅ์„ ๊ฐ€์ง„ ์ „๋ฌธ๊ฐ€๋“ค์ด ๊ธฐ๋‹ค๋ฆฌ๊ณ  ์žˆ์–ด์š”. ๐ŸŒŸ
์žฌ๋Šฅ๋„ท์—์„œ ๋‹น์‹ ์˜ ๊ฐœ๋ฐœ ์—ฌ์ •์„ ํ•จ๊ป˜ํ•˜์„ธ์š”!

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.