Conversational AI: Chatbot Geliştirme Best Practices
Conversational AI, doğal dil ile insan-bilgisayar etkileşimini sağlayan sistemlerdir. Bu rehberde kurumsal chatbot geliştirme stratejilerini inceliyoruz.
Chatbot Mimarisi
Temel Bileşenler
1┌────────────────────────────────────────────────────┐ 2│ User Interface │ 3└───────────────────────┬────────────────────────────┘ 4 │ 5┌───────────────────────▼────────────────────────────┐ 6│ Input Processing Layer │ 7│ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │ 8│ │ Speech │ │ Text │ │ Multimodal │ │ 9│ │ to Text │ │ Normalize│ │ Processing │ │ 10│ └──────────┘ └──────────┘ └────────────────┘ │ 11└───────────────────────┬────────────────────────────┘ 12 │ 13┌───────────────────────▼────────────────────────────┐ 14│ Dialog Manager │ 15│ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │ 16│ │ Intent │ │ State │ │ Context │ │ 17│ │ Detection│ │ Manager │ │ Handler │ │ 18│ └──────────┘ └──────────┘ └────────────────┘ │ 19└───────────────────────┬────────────────────────────┘ 20 │ 21┌───────────────────────▼────────────────────────────┐ 22│ Response Generation │ 23│ ┌──────────┐ ┌──────────┐ ┌────────────────┐ │ 24│ │ LLM │ │ Template │ │ Action │ │ 25│ │ Response │ │ Engine │ │ Executor │ │ 26│ └──────────┘ └──────────┘ └────────────────┘ │ 27└────────────────────────────────────────────────────┘
Context Management
Conversation Memory
1from typing import List, Dict 2from datetime import datetime 3 4class ConversationMemory: 5 def __init__(self, max_turns: int = 10): 6 self.max_turns = max_turns 7 self.history: List[Dict] = [] 8 self.metadata: Dict = {} 9 10 def add_message(self, role: str, content: str): 11 message = { 12 "role": role, 13 "content": content, 14 "timestamp": datetime.now().isoformat() 15 } 16 self.history.append(message) 17 18 # Eski mesajları temizle 19 if len(self.history) > self.max_turns * 2: 20 self.history = self.history[-self.max_turns * 2:] 21 22 def get_context(self) -> List[Dict]: 23 return [{"role": m["role"], "content": m["content"]} 24 for m in self.history] 25 26 def summarize(self, llm_client) -> str: 27 """Uzun konuşmaları özetle""" 28 if len(self.history) < 10: 29 return None 30 31 response = llm_client.chat.completions.create( 32 model="gpt-4-turbo", 33 messages=[ 34 {"role": "system", "content": "Bu konuşmayı özetle."}, 35 {"role": "user", "content": str(self.history)} 36 ] 37 ) 38 return response.choices[0].message.content
Session State
1class SessionState: 2 def __init__(self, session_id: str): 3 self.session_id = session_id 4 self.user_info: Dict = {} 5 self.collected_data: Dict = {} 6 self.current_intent: str = None 7 self.current_step: str = None 8 self.awaiting_input: str = None 9 10 def set_slot(self, name: str, value: any): 11 self.collected_data[name] = value 12 13 def get_slot(self, name: str) -> any: 14 return self.collected_data.get(name) 15 16 def clear_slots(self): 17 self.collected_data = {} 18 19 def is_complete(self, required_slots: List[str]) -> bool: 20 return all(slot in self.collected_data for slot in required_slots)
Intent Classification
LLM-based Intent Detection
1def detect_intent(user_message: str, available_intents: List[Dict]) -> Dict: 2 intent_descriptions = "\n".join([ 3 f"- {intent['name']}: {intent['description']}" 4 for intent in available_intents 5 ]) 6 7 response = client.chat.completions.create( 8 model="gpt-4-turbo", 9 response_format={"type": "json_object"}, 10 messages=[ 11 { 12 "role": "system", 13 "content": f"""Kullanıcı mesajının intent'ini belirle. 14 15Mevcut intent'ler: 16{intent_descriptions} 17 18JSON formatında yanıt ver: 19{{"intent": "intent_name", "confidence": 0.0-1.0, "entities": {{}}}} 20""" 21 }, 22 {"role": "user", "content": user_message} 23 ] 24 ) 25 26 return json.loads(response.choices[0].message.content)
Hybrid Intent Detection
1from sklearn.feature_extraction.text import TfidfVectorizer 2from sklearn.linear_model import LogisticRegression 3 4class HybridIntentClassifier: 5 def __init__(self): 6 self.ml_classifier = None 7 self.vectorizer = TfidfVectorizer() 8 9 def train_ml(self, texts: List[str], labels: List[str]): 10 X = self.vectorizer.fit_transform(texts) 11 self.ml_classifier = LogisticRegression() 12 self.ml_classifier.fit(X, labels) 13 14 def classify(self, text: str) -> Dict: 15 # ML prediction 16 X = self.vectorizer.transform([text]) 17 ml_intent = self.ml_classifier.predict(X)[0] 18 ml_confidence = max(self.ml_classifier.predict_proba(X)[0]) 19 20 # Düşük confidence ise LLM'e sor 21 if ml_confidence < 0.7: 22 llm_result = detect_intent(text, self.available_intents) 23 return llm_result 24 25 return {"intent": ml_intent, "confidence": ml_confidence}
Dialog Flow
State Machine
1from enum import Enum 2 3class OrderState(Enum): 4 START = "start" 5 PRODUCT_SELECTION = "product_selection" 6 QUANTITY = "quantity" 7 ADDRESS = "address" 8 CONFIRMATION = "confirmation" 9 COMPLETE = "complete" 10 11class OrderFlow: 12 def __init__(self): 13 self.state = OrderState.START 14 self.data = {} 15 16 def process(self, user_input: str, intent: str) -> str: 17 if self.state == OrderState.START: 18 if intent == "order": 19 self.state = OrderState.PRODUCT_SELECTION 20 return "Hangi ürünü sipariş etmek istiyorsunuz?" 21 22 elif self.state == OrderState.PRODUCT_SELECTION: 23 self.data["product"] = user_input 24 self.state = OrderState.QUANTITY 25 return f"{user_input} seçtiniz. Kaç adet istiyorsunuz?" 26 27 elif self.state == OrderState.QUANTITY: 28 self.data["quantity"] = int(user_input) 29 self.state = OrderState.ADDRESS 30 return "Teslimat adresinizi belirtir misiniz?" 31 32 elif self.state == OrderState.ADDRESS: 33 self.data["address"] = user_input 34 self.state = OrderState.CONFIRMATION 35 return f"Sipariş özeti:\n{self.data}\nOnaylıyor musunuz?" 36 37 elif self.state == OrderState.CONFIRMATION: 38 if "evet" in user_input.lower(): 39 self.state = OrderState.COMPLETE 40 return "Siparişiniz alındı. Teşekkürler!" 41 else: 42 self.state = OrderState.START 43 return "Sipariş iptal edildi."
Response Generation
Template + LLM Hybrid
1class ResponseGenerator: 2 def __init__(self): 3 self.templates = { 4 "greeting": [ 5 "Merhaba! Size nasıl yardımcı olabilirim?", 6 "Hoş geldiniz! Bugün ne yapmak istersiniz?" 7 ], 8 "farewell": [ 9 "İyi günler! Tekrar görüşmek üzere.", 10 "Başka bir sorunuz olursa burdayım. Hoşça kalın!" 11 ] 12 } 13 14 def generate(self, intent: str, context: Dict) -> str: 15 # Basit intent'ler için template 16 if intent in self.templates: 17 return random.choice(self.templates[intent]) 18 19 # Karmaşık intent'ler için LLM 20 return self.llm_generate(intent, context) 21 22 def llm_generate(self, intent: str, context: Dict) -> str: 23 system_prompt = f"""Sen yardımcı bir müşteri hizmetleri asistanısın. 24Kullanıcı intent'i: {intent} 25Mevcut context: {json.dumps(context, ensure_ascii=False)} 26 27Kurallar: 28- Kısa ve öz cevap ver 29- Samimi ama profesyonel ol 30- Gerekirse takip soruları sor 31""" 32 33 response = client.chat.completions.create( 34 model="gpt-4-turbo", 35 messages=[ 36 {"role": "system", "content": system_prompt}, 37 *context.get("history", []) 38 ] 39 ) 40 41 return response.choices[0].message.content
Fallback Handling
1class FallbackHandler: 2 def __init__(self): 3 self.fallback_count = 0 4 self.max_fallbacks = 3 5 6 def handle(self, user_input: str, context: Dict) -> str: 7 self.fallback_count += 1 8 9 if self.fallback_count >= self.max_fallbacks: 10 self.fallback_count = 0 11 return self.human_handoff(context) 12 13 responses = [ 14 "Anlayamadım. Başka bir şekilde ifade edebilir misiniz?", 15 "Bu konuda size yardımcı olamıyorum. Farklı bir soru sorabilirsiniz.", 16 "Sanırım sizi doğru anlamadım. Lütfen tekrar dener misiniz?" 17 ] 18 19 return responses[self.fallback_count - 1] 20 21 def human_handoff(self, context: Dict) -> str: 22 # Insan temsilciye aktarma 23 create_support_ticket(context) 24 return "Sizi bir müşteri temsilcisine bağlıyorum. Lütfen bekleyin."
Analytics ve Monitoring
1class ChatAnalytics: 2 def __init__(self): 3 self.metrics = { 4 "total_conversations": 0, 5 "successful_resolutions": 0, 6 "fallback_rate": 0, 7 "avg_turns_per_conversation": 0, 8 "intent_distribution": {} 9 } 10 11 def log_conversation(self, conversation: Dict): 12 self.metrics["total_conversations"] += 1 13 14 # Intent tracking 15 for message in conversation["messages"]: 16 if "intent" in message: 17 intent = message["intent"] 18 self.metrics["intent_distribution"][intent] = \ 19 self.metrics["intent_distribution"].get(intent, 0) + 1 20 21 # Resolution tracking 22 if conversation.get("resolved"): 23 self.metrics["successful_resolutions"] += 1 24 25 def get_resolution_rate(self) -> float: 26 if self.metrics["total_conversations"] == 0: 27 return 0 28 return self.metrics["successful_resolutions"] / self.metrics["total_conversations"]
Production Checklist
Güvenlik
- Input sanitization
- Rate limiting
- PII masking
- Injection protection
Performans
- Response time < 2s
- Concurrent users support
- Caching layer
- Auto-scaling
Kullanıcı Deneyimi
- Typing indicators
- Error messages
- Conversation history
- Multi-language support
Sonuç
Conversational AI, müşteri etkileşimlerini dönüştüren güçlü bir teknolojidir. İyi tasarlanmış dialog flow, robust error handling ve sürekli iyileştirme ile başarılı chatbot'lar oluşturabilirsiniz.
Veni AI olarak, kurumsal chatbot çözümleri geliştiriyoruz.