A proper development environment is crucial for AI chatbot development. We'll start by installing Python, setting up a virtual environment, and installing all necessary dependencies.

Your environment is now ready! The virtual environment ensures clean dependency management and prevents conflicts with system packages.

Secure API key management is essential for production applications. We'll set up environment variables to keep your credentials safe and make your application configurable.

Now we'll build the heart of our chatbot using LangChain's powerful abstractions. This step creates the foundational conversation logic that will power your AI assistant.

Create a file called chatbot.py with the following code:

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage, AIMessage, SystemMessage
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Load environment variables
load_dotenv()

class AIChatbot:
    def __init__(self):
        """Initialize the chatbot with OpenAI and LangChain"""
        self.llm = ChatOpenAI(
            model=os.getenv("OPENAI_MODEL", "gpt-4-turbo"),
            temperature=float(os.getenv("OPENAI_TEMPERATURE", "0.7")),
            openai_api_key=os.getenv("OPENAI_API_KEY")
        )

        # Initialize memory for conversation context
        self.memory = ConversationBufferMemory(
            memory_key="history",
            return_messages=True
        )

        # Create conversation chain
        self.conversation = ConversationChain(
            llm=self.llm,
            memory=self.memory,
            verbose=True
        )

        # Set system message for chatbot personality
        self.system_message = SystemMessage(
            content="""You are a helpful AI assistant created in 2025. You are:
            - Friendly and professional
            - Knowledgeable about current technology
            - Able to maintain conversation context
            - Respectful and ethical in all responses

            Respond in a conversational manner while being helpful and accurate."""
        )

    def chat(self, user_message):
        """Process user message and return AI response"""
        try:
            # Format message for LangChain
            messages = [self.system_message, HumanMessage(content=user_message)]

            # Get response from the model
            response = self.conversation.predict(input=user_message)

            return response

        except Exception as e:
            return f"I apologize, but I encountered an error: {str(e)}"

    def clear_memory(self):
        """Clear conversation history"""
        self.memory.clear()
        return "Conversation history cleared. How can I help you today?"

# Initialize chatbot instance
chatbot = AIChatbot()

if __name__ == "__main__":
    print("🤖 AI Chatbot 2025 - Type 'quit' to exit")
    print("─" * 50)

    while True:
        user_input = input("\nYou: ")
        if user_input.lower() == 'quit':
            break

        response = chatbot.chat(user_input)
        print(f"\nAssistant: {response}")

Before adding the web interface, let's test our chatbot's core functionality. This ensures everything works correctly before moving to the next complexity level.

Expected output should look like this:

🤖 AI Chatbot 2025 - Type 'quit' to exit
──────────────────────────────────────────────────

You: Hello, can you help me understand AI?

Assistant: Hello! I'd be happy to help you understand AI! Artificial Intelligence refers to computer systems designed to perform tasks that typically require human intelligence...

You: What are the main types of AI?

Assistant: Building on our conversation about AI, there are several main types: Narrow AI (which we see today in applications like virtual assistants), General AI (which would match human intelligence across all domains), and Superintelligence...

Now we'll create an interactive web interface using Streamlit. This will provide users with a modern, chat-like experience similar to popular AI assistants.

Create a new file called app.py with the following code:

import streamlit as st
import time
from chatbot import AIChatbot
import os

# Configure Streamlit page
st.set_page_config(
    page_title="AI Chatbot 2025",
    page_icon="🤖",
    layout="centered",
    initial_sidebar_state="expanded"
)

# Custom CSS for better styling
st.markdown("""

""", unsafe_allow_html=True)

# Initialize chatbot
@st.cache_resource
def load_chatbot():
    return AIChatbot()

chatbot = load_chatbot()

# Initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = [
        {"role": "assistant", "content": "👋 Hello! I'm your AI assistant built with 2025 technology. How can I help you today?"}
    ]

# Sidebar with options
with st.sidebar:
    st.title("🤖 AI Chatbot Settings")

    # Clear conversation button
    if st.button("🗑️ Clear Conversation"):
        st.session_state.messages = [
            {"role": "assistant", "content": "👋 Conversation cleared! How can I help you today?"}
        ]
        chatbot.clear_memory()
        st.rerun()

    # Display conversation stats
    st.write(f"**Messages:** {len(st.session_state.messages)}")

    # Model info
    st.write("**Model:** GPT-4 Turbo")
    st.write("**Framework:** LangChain v0.3")

# Main chat interface
st.title("🤖 AI Chatbot 2025")
st.write("Powered by LangChain v0.3 and OpenAI GPT-4 Turbo")

# Display chat messages
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# Chat input
if prompt := st.chat_input("Type your message here..."):
    # Add user message to chat history
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)

    # Generate assistant response
    with st.chat_message("assistant"):
        message_placeholder = st.empty()
        full_response = ""

        # Show typing indicator
        with st.spinner("🤔 Thinking..."):
            response = chatbot.chat(prompt)

        # Simulate typing effect
        for chunk in response.split():
            full_response += chunk + " "
            time.sleep(0.05)
            message_placeholder.markdown(full_response + "▌")

        message_placeholder.markdown(full_response)

    # Add assistant response to chat history
    st.session_state.messages.append({"role": "assistant", "content": full_response})

# Footer
st.markdown("---")
st.markdown("*Built with ❤️ using Streamlit, LangChain, and OpenAI*")

Let's test your web interface to ensure everything works smoothly before deploying. This step validates the complete chatbot experience.

Your web interface should feature:

• Modern chat interface similar to ChatGPT
• Responsive design that works on mobile and desktop
• Sidebar with settings and conversation controls
• Real-time typing indicator for better UX
• Persistent conversation history

Let's enhance your chatbot with advanced features that make it more useful and professional. These improvements will set your chatbot apart from basic implementations.

Add these enhancements to your chatbot.py file:

# Add these imports at the top
from datetime import datetime
import json

# Enhanced AIChatbot class with new features
class AIChatbot:
    def __init__(self):
        # ... (keep existing initialization code)
        self.conversation_start_time = datetime.now()
        self.message_count = 0

    def chat(self, user_message):
        """Enhanced chat with additional features"""
        self.message_count += 1

        # Log conversation for analytics
        self._log_conversation(user_message)

        try:
            # Add context awareness
            context_aware_message = self._add_context(user_message)

            # Get response from the model
            response = self.conversation.predict(input=context_aware_message)

            # Enhance response with formatting
            formatted_response = self._format_response(response)

            return formatted_response

        except Exception as e:
            return f"I apologize, but I encountered an error: {str(e)}"

    def _add_context(self, message):
        """Add temporal context to messages"""
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M")
        conversation_duration = (datetime.now() - self.conversation_start_time).seconds

        context_prefix = f"[Current time: {current_time}, Messages: {self.message_count}, Duration: {conversation_duration}s] "

        return context_prefix + message

    def _format_response(self, response):
        """Format response with markdown and structure"""
        # Add formatting for better readability
        if "?" in response[-10:]:  # If response ends with a question
            return response + "\n\n*What are your thoughts on this?*"

        return response

    def _log_conversation(self, user_message):
        """Log conversation for analysis"""
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "message_count": self.message_count,
            "message_length": len(user_message),
            "type": "user_input"
        }

        # In production, save to database
        print(f"LOG: {json.dumps(log_entry)}")

    def get_conversation_stats(self):
        """Return conversation statistics"""
        duration = (datetime.now() - self.conversation_start_time).seconds
        return {
            "duration": duration,
            "message_count": self.message_count,
            "avg_response_time": duration / max(self.message_count, 1)
        }

The final step prepares your chatbot for production deployment. We'll create deployment configurations and set up monitoring for a professional-grade application.

Create a Dockerfile in your project root:

FROM python:3.12-slim

WORKDIR /app

# Copy requirements first for better caching
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose port
EXPOSE 8501

# Health check
HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8501/_stcore/health || exit 1

# Run the application
CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

Create docker-compose.yml for easy deployment:

version: '3.8'

services:
  chatbot:
    build: .
    ports:
      - "8501:8501"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - OPENAI_MODEL=gpt-4-turbo
      - OPENAI_TEMPERATURE=0.7
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8501/_stcore/health"]
      interval: 30s
      timeout: 10s
      retries: 3

For deployment, you have several options:

• Streamlit Cloud: Easiest for beginners - connect your GitHub repo
• Heroku: Good for small to medium applications
• AWS/Google Cloud: For enterprise-level deployments
• Docker Swarm/Kubernetes: For scalable microservices architecture