Building AI Chatbots

pip install streamlit openai python-dotenv
echo "OPENAI_API_KEY=sk-your-key" > .env

import streamlit as st
import openai
import os
from dotenv import load_dotenv

load_dotenv()
client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Configuration
SYSTEM_PROMPT = """You are a helpful customer support agent for a SaaS product.
You are friendly, concise, and solution-oriented.
If you do not know the answer, say so honestly and offer to escalate.
Never make up product features or pricing."""

MAX_HISTORY = 20  # keep last 20 messages for context

st.set_page_config(page_title="AI Support Bot", page_icon="chat")
st.title("AI Support Bot")

# Initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = []

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

# Chat input
if prompt := st.chat_input("How can I help you?"):
    # Add user message
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)

    # Build messages for API
    api_messages = [{"role": "system", "content": SYSTEM_PROMPT}]
    api_messages += st.session_state.messages[-MAX_HISTORY:]

    # Stream the response
    with st.chat_message("assistant"):
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=api_messages,
            stream=True
        )
        response = st.write_stream(stream)

    st.session_state.messages.append({"role": "assistant", "content": response})

Run it: streamlit run chatbot.py

import numpy as np

# 1. Prepare your knowledge base
knowledge_base = [
    "Our product costs $29/month for the starter plan and $99/month for pro.",
    "We offer a 14-day free trial with no credit card required.",
    "Supported integrations include Slack, Jira, GitHub, and Notion.",
    "To reset your password, go to Settings > Security > Change Password.",
    "Our API rate limit is 1000 requests per minute on the pro plan.",
]

# 2. Create embeddings for the knowledge base
def embed_texts(texts: list[str]) -> list[list[float]]:
    response = client.embeddings.create(model="text-embedding-3-small", input=texts)
    return [item.embedding for item in response.data]

kb_embeddings = embed_texts(knowledge_base)

# 3. Search function
def search_knowledge(query: str, top_k: int = 3) -> list[str]:
    query_emb = embed_texts([query])[0]
    scores = [
        np.dot(query_emb, kb_emb) / (np.linalg.norm(query_emb) * np.linalg.norm(kb_emb))
        for kb_emb in kb_embeddings
    ]
    top_indices = np.argsort(scores)[-top_k:][::-1]
    return [knowledge_base[i] for i in top_indices if scores[i] > 0.3]

# 4. Inject into chatbot
def build_messages_with_rag(user_query: str, history: list) -> list:
    context = search_knowledge(user_query)
    system = SYSTEM_PROMPT
    if context:
        system += f"\n\nRelevant information:\n" + "\n".join(f"- {c}" for c in context)
    messages = [{"role": "system", "content": system}]
    messages += history[-MAX_HISTORY:]
    return messages

def summarize_history(messages: list[dict], keep_recent: int = 6) -> list[dict]:
    if len(messages) <= keep_recent:
        return messages

    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Summarize old messages
    summary_resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Summarize this conversation in 2-3 sentences, preserving key facts and decisions."},
            {"role": "user", "content": str(old_messages)}
        ],
        max_tokens=200
    )
    summary = summary_resp.choices[0].message.content

    return [{"role": "system", "content": f"Previous conversation summary: {summary}"}] + recent_messages