Veni AI
Sztuczna inteligencja konwersacyjna

Sztuczna inteligencja konwersacyjna: najlepsze praktyki tworzenia chatbotów

Przewodnik po tworzeniu chatbotów dla przedsiębiorstw, zarządzaniu dialogiem, obsłudze kontekstu, projektowaniu konwersacji oraz architekturze chatbotów gotowych do produkcji.

Veni AI Technical Team1 Ocak 20256 dk okuma
Sztuczna inteligencja konwersacyjna: najlepsze praktyki tworzenia chatbotów

Konwersacyjna AI: Najlepsze praktyki tworzenia chatbotów

Systemy konwersacyjnej AI umożliwiają interakcję człowieka z komputerem za pomocą języka naturalnego. W tym przewodniku analizujemy strategie tworzenia chatbotów dla przedsiębiorstw.

Architektura chatbota

Kluczowe komponenty

1┌────────────────────────────────────────────────────┐
2│                    User Interface                   │
3└───────────────────────┬────────────────────────────┘
4                        │
5┌───────────────────────▼────────────────────────────┐
6│              Input Processing Layer                 │
7│  ┌──────────┐  ┌──────────┐  ┌────────────────┐   │
8│  │  Speech  │  │   Text   │  │   Multimodal   │   │
9│  │  to Text │  │ Normalize│  │   Processing   │   │
10│  └──────────┘  └──────────┘  └────────────────┘   │
1130: └───────────────────────┬────────────────────────────┘
12                        │
13┌───────────────────────▼────────────────────────────┐
14│                 Dialog Manager                      │
15│  ┌──────────┐  ┌──────────┐  ┌────────────────┐   │
16│  │  Intent  │  │  State   │  │    Context     │   │
17│  │ Detection│  │ Manager  │  │    Handler     │   │
18│  └──────────┘  └──────────┘  └────────────────┘   │
1938: └───────────────────────┬────────────────────────────┘
20                        │
21┌───────────────────────▼────────────────────────────┐
22│              Response Generation                    │
23│  ┌──────────┐  ┌──────────┐  ┌────────────────┐   │
24│  │   LLM    │  │ Template │  │     Action     │   │
25│  │ Response │  │  Engine  │  │    Executor    │   │
26│  └──────────┘  └──────────┘  └────────────────┘   │
2746: └────────────────────────────────────────────────────┘

Zarządzanie kontekstem

Pamięć konwersacji

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        # Clean old messages
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        """Summarize long conversations"""
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": "Summarize this conversation."},
35                {"role": "user", "content": str(self.history)}
36            ]
37        )
38        return response.choices[0].message.content

Stan sesji

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)
21## Klasyfikacja intencji
22
23### Wykrywanie intencji oparte na LLM
24
25```python
26def detect_intent(user_message: str, available_intents: List[Dict]) -> Dict:
27    intent_descriptions = "\n".join([
28        f"- {intent['name']}: {intent['description']}"
29        for intent in available_intents
30    ])
31    
32    response = client.chat.completions.create(
33        model="gpt-4-turbo",
34        response_format={"type": "json_object"},
35        messages=[
36            {
37                "role": "system",
38                "content": f"""Determine the intent of the user message.
39                
40Available intents:
41{intent_descriptions}
42
43Respond in JSON format:
44{{"intent": "intent_name", "confidence": 0.0-1.0, "entities": {{}}}}
45"""
46            },
47            {"role": "user", "content": user_message}
48        ]
49    )
50    
51    return json.loads(response.choices[0].message.content)

Hybrydowe wykrywanie intencji

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        # Ask LLM if confidence is low
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}

Przepływ dialogu

Maszyna stanów

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 "Który produkt chcesz zamówić?"
21        
22        elif self.state == OrderState.PRODUCT_SELECTION:
23            self.data["product"] = user_input
24            self.state = OrderState.QUANTITY
25            return f"Wybrałeś {user_input}. Ile sztuk chcesz zamówić?"
26        
27        elif self.state == OrderState.QUANTITY:
28            self.data["quantity"] = int(user_input)
29            self.state = OrderState.ADDRESS
30            return "Podaj proszę adres dostawy."
31        
32        elif self.state == OrderState.ADDRESS:
33            self.data["address"] = user_input
34            self.state = OrderState.CONFIRMATION
35            return f"Podsumowanie zamówienia:\n{self.data}\nCzy potwierdzasz?"
36        
37        elif self.state == OrderState.CONFIRMATION:
38            if "yes" in user_input.lower():
39                self.state = OrderState.COMPLETE
40                return "Zamówienie przyjęte. Dziękujemy!"
41            else:
42                self.state = OrderState.START
43                return "Zamówienie anulowane."
44## Generowanie odpowiedzi
45
46### Hybryda szablonu i LLM
47
48```python
49class ResponseGenerator:
50    def __init__(self):
51        self.templates = {
52            "greeting": [
53                "Hello! How can I help you?",
54                "Welcome! What would you like to do today?"
55            ],
56            "farewell": [
57                "Have a good day! See you again.",
58                "I'm here if you have any other questions. Goodbye!"
59            ]
60        }
61    
62    def generate(self, intent: str, context: Dict) -> str:
63        # Template for simple intents
64        if intent in self.templates:
65            return random.choice(self.templates[intent])
66        
67        # LLM for complex intents
68        return self.llm_generate(intent, context)
69    
70    def llm_generate(self, intent: str, context: Dict) -> str:
71        system_prompt = f"""You are a helpful customer service assistant.
72User intent: {intent}
73Current context: {json.dumps(context, ensure_ascii=False)}
74
75Rules:
76- Give short and concise answers
77- Be friendly but professional
78- Ask follow-up questions if necessary
79"""
80        
81        response = client.chat.completions.create(
82            model="gpt-4-turbo",
83            messages=[
84                {"role": "system", "content": system_prompt},
85                *context.get("history", [])
86            ]
87        )
88        
89        return response.choices[0].message.content

Obsługa sytuacji awaryjnych (Fallback)

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            "I didn't understand. Could you rephrase that?",
15            "I cannot help with this. You can ask a different question.",
16            "I think I misunderstood you. could you try again?"
17        ]
18        
19        return responses[self.fallback_count - 1]
20    
21    def human_handoff(self, context: Dict) -> str:
22        # Hand off to human agent
23        create_support_ticket(context)
24        return "I am connecting you to a customer representative. Please wait."

Analityka i monitorowanie

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"]

Lista kontrolna dla produkcji

Bezpieczeństwo

  • Sanityzacja danych wejściowych
  • Ograniczanie liczby żądań (Rate limiting)
  • Maskowanie PII
  • Ochrona przed atakami typu injection

Wydajność

  • Czas odpowiedzi < 2s
  • Obsługa wielu jednoczesnych użytkowników
  • Warstwa cache
  • Auto-skalowanie

Doświadczenie użytkownika

  • Wskaźniki pisania
  • Komunikaty o błędach
  • Historia konwersacji
  • Obsługa wielu języków

Podsumowanie

Konwersacyjne AI to potężna technologia, która przekształca interakcje z klientami. Możesz tworzyć skuteczne chatboty dzięki dobrze zaprojektowanemu przebiegowi dialogu, solidnej obsłudze błędów i ciągłemu doskonaleniu.

W Veni AI tworzymy rozwiązania chatbotowe klasy enterprise.

İlgili Makaleler

Agenci AI

Standardy agentów AI w przedsiębiorstwach: wzorce operacyjne wyłaniające się na początku 2026 roku

Daha fazla oku →
Zarządzanie AI

Zarządzanie sztuczną inteligencją w przedsiębiorstwach: rejestr modeli i standardy ewaluacji

Daha fazla oku →
RAG

Rozwój multimodalnego RAG: łączenie wyszukiwania wektorowego i grafowego

Daha fazla oku →