Conversational AI & Chatbots — Architecture and Design

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
from collections import deque

class ConversationalBot:
    """Simple multi-turn chatbot with sliding context window."""

    def __init__(self, model_name="microsoft/DialoGPT-medium",
                 max_history_turns=5):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model     = AutoModelForCausalLM.from_pretrained(model_name)
        self.history   = deque(maxlen=max_history_turns * 2)  # user+bot turns
        self.model.eval()

    def chat(self, user_input: str) -> str:
        # Encode user input
        user_ids = self.tokenizer.encode(
            user_input + self.tokenizer.eos_token, return_tensors='pt')

        # Build context: all history + current input
        if self.history:
            context_ids = torch.cat([
                torch.cat(list(self.history), dim=-1),
                user_ids
            ], dim=-1)
        else:
            context_ids = user_ids

        # Generate response
        with torch.no_grad():
            response_ids = self.model.generate(
                context_ids,
                max_new_tokens=200,
                pad_token_id=self.tokenizer.eos_token_id,
                do_sample=True, top_p=0.92, temperature=0.7,
                no_repeat_ngram_size=3,    # Prevent repetition
            )

        # Extract only the new tokens (not the input)
        new_tokens    = response_ids[:, context_ids.shape[-1]:]
        response_text = self.tokenizer.decode(new_tokens[0], skip_special_tokens=True)

        # Store turn in history
        self.history.append(user_ids)
        self.history.append(new_tokens)

        return response_text

    def reset(self):
        self.history.clear()
        print("Conversation history cleared.")

# ── Production pattern: OpenAI API with conversation history ──
from openai import OpenAI
client = OpenAI()   # Requires OPENAI_API_KEY

def chat_with_memory(user_message: str, conversation_history: list) -> str:
    """Production pattern: send full history to LLM API each turn."""
    conversation_history.append({"role": "user", "content": user_message})
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are a helpful NLP tutor."},
            *conversation_history,
        ],
        max_tokens=500,
        temperature=0.7,
    )
    assistant_reply = response.choices[0].message.content
    conversation_history.append({"role": "assistant", "content": assistant_reply})
    return assistant_reply

# Each API call sends the FULL conversation history
# This is how ChatGPT/Claude maintain context — no server-side state
# The "memory" is in the client, passed as context each turn
history = []
for user_msg in ["What is BERT?", "How is it different from GPT?", "Which is better for chatbots?"]:
    reply = chat_with_memory(user_msg, history)
    print(f"User: {user_msg}")
    print(f"Bot:  {reply[:100]}")
    print()