Agentic AI Assistants: Xây Chatbot Thông Minh Thực Hiện Task Cho Website 2026

from openai import OpenAI
import json

client = OpenAI(api_key="your-api-key")

# Định nghĩa tools mà agent có thể dùng
tools = [
    {
        "type": "function",
        "function": {
            "name": "check_inventory",
            "description": "Kiểm tra số lượng tồn kho của sản phẩm",
            "parameters": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "string", "description": "ID sản phẩm"},
                    "size": {"type": "string", "description": "Kích cỡ: S, M, L, XL"}
                },
                "required": ["product_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "add_to_cart",
            "description": "Thêm sản phẩm vào giỏ hàng của khách",
            "parameters": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "string"},
                    "quantity": {"type": "integer"},
                    "user_id": {"type": "string"}
                },
                "required": ["product_id", "quantity", "user_id"]
            }
        }
    }
]

# Khởi tạo assistant với persona tiếng Việt
assistant = client.beta.assistants.create(
    name="Shop Assistant",
    instructions="""Bạn là trợ lý mua sắm của một shop thời trang Việt Nam.
    Luôn trả lời bằng tiếng Việt, thân thiện.
    Khi khách hỏi về sản phẩm, CHỦ ĐỘNG kiểm tra kho trước khi trả lời.
    Nếu còn hàng, gợi ý thêm sản phẩm liên quan.""",
    model="gpt-4o",
    tools=tools
)

print(f"Assistant ID: {assistant.id}")

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
from typing import TypedDict, List

# Định nghĩa state của agent
class ShopAgentState(TypedDict):
    messages: List
    user_id: str
    cart_items: List
    intent: str  # browse | buy | support

# Node: phân tích intent của khách
def analyze_intent(state: ShopAgentState):
    llm = ChatOpenAI(model="gpt-4o")
    last_msg = state["messages"][-1].content
    
    response = llm.invoke([
        HumanMessage(content=f"""
        Phân tích intent của tin nhắn này (chỉ trả về 1 trong 3: browse/buy/support):
        '{last_msg}'
        """)
    ])
    
    return {"intent": response.content.strip()}

# Node: xử lý intent mua hàng
def handle_buy_intent(state: ShopAgentState):
    # Gọi API kho hàng, tạo giỏ hàng...
    llm = ChatOpenAI(model="gpt-4o")
    response = llm.invoke(state["messages"] + [
        HumanMessage(content="Kiểm tra kho và tư vấn mua hàng cho khách")
    ])
    return {"messages": state["messages"] + [AIMessage(content=response.content)]}

# Router: chọn node tiếp theo dựa trên intent
def route_by_intent(state: ShopAgentState):
    if state["intent"] == "buy":
        return "handle_buy"
    elif state["intent"] == "support":
        return "handle_support"
    return "handle_browse"

# Tạo graph
workflow = StateGraph(ShopAgentState)
workflow.add_node("analyze", analyze_intent)
workflow.add_node("handle_buy", handle_buy_intent)

# Thêm edges với conditional routing
workflow.set_entry_point("analyze")
workflow.add_conditional_edges("analyze", route_by_intent, {
    "handle_buy": "handle_buy",
    "handle_support": END,
    "handle_browse": END
})
workflow.add_edge("handle_buy", END)

# Bật memory để nhớ xuyên session
memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# Chạy với config session
config = {"configurable": {"thread_id": "user-123"}}
result = app.invoke(
    {
        "messages": [HumanMessage(content="Tôi muốn mua hoodie size L")],
        "user_id": "user-123",
        "cart_items": [],
        "intent": ""
    },
    config=config
)

import anthropic

client = anthropic.Anthropic(api_key="your-key")

# Định nghĩa tools theo format Anthropic
tools = [
    {
        "name": "search_products",
        "description": "Tìm kiếm sản phẩm theo từ khóa, lọc theo giá, size, màu sắc",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Từ khóa tìm kiếm"},
                "max_price": {"type": "number", "description": "Giá tối đa (VNĐ)"},
                "category": {"type": "string"}
            },
            "required": ["query"]
        }
    }
]

# Gọi Claude với tool use
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system="""Bạn là AI assistant cho shop thời trang tại TP.HCM.
    Luôn dùng tool search_products trước khi tư vấn sản phẩm.
    Trả lời ngắn gọn, friendly, bằng tiếng Việt.""",
    tools=tools,
    messages=[
        {"role": "user", "content": "Mình muốn tìm áo khoác dưới 500k"}
    ]
)

# Xử lý tool call nếu có
for block in response.content:
    if block.type == "tool_use":
        tool_name = block.name
        tool_input = block.input
        print(f"Claude gọi tool: {tool_name} với params: {tool_input}")
        
        # Gọi function thực tế của bạn
        # result = your_search_function(**tool_input)
        # Rồi trả kết quả lại cho Claude để tạo response cuối

from openai import OpenAI
from datetime import datetime

client = OpenAI()

# Giả lập data từ database khách hàng
user_profile = {
    "user_id": "vn-user-456",
    "name": "Anh Tuấn",
    "purchase_history": ["áo thun basic", "quần jogger", "sneakers trắng"],
    "preferred_price_range": "300k-800k",
    "last_visit": "2025-12-10"
}

def get_personalized_recommendation(user_data: dict, current_page: str) -> str:
    """Agent phân tích context và gợi ý cá nhân hóa"""
    
    context = f"""
    Thông tin khách hàng:
    - Đã mua: {', '.join(user_data['purchase_history'])}
    - Ngân sách: {user_data['preferred_price_range']}
    - Đang xem trang: {current_page}
    - Ngày hôm nay: {datetime.now().strftime('%d/%m/%Y')}
    """
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": """Bạn là shopping assistant AI của một fashion e-commerce Việt Nam.
                Dựa trên lịch sử mua hàng, hãy gợi ý 2-3 sản phẩm bổ sung phù hợp.
                Format: tên sản phẩm | lý do gợi ý | khoảng giá.
                Ngắn gọn, friendly, tiếng Việt."""
            },
            {
                "role": "user",
                "content": context + "\nHãy gợi ý sản phẩm phù hợp cho khách này."
            }
        ],
        temperature=0.7
    )
    
    return response.choices[0].message.content

# Chạy thử
result = get_personalized_recommendation(
    user_data=user_profile,
    current_page="/san-pham/ao-khoac-bomber"
)
print(result)
# Output ví dụ:
# 1. Quần cargo | Hợp với bomber, phong cách streetwear | 350k-500k
# 2. Mũ bucket | Hoàn thiện outfit casual | 150k-250k  
# 3. Túi tote canvas | Đã có sneakers trắng, túi này match cực | 200k-350k

// Nhúng vào bất kỳ trang web nào
(function() {
  // Tạo widget container
  const widget = document.createElement('div');
  widget.id = 'ai-agent-widget';
  widget.style.cssText = `
    position: fixed; bottom: 24px; right: 24px;
    width: 380px; height: 500px;
    background: white; border-radius: 16px;
    box-shadow: 0 8px 32px rgba(0,0,0,0.15);
    display: flex; flex-direction: column;
    font-family: system-ui, sans-serif;
    z-index: 9999;
  `;
  
  // Header
  widget.innerHTML = `
    <div style="background: #0f172a; color: white; padding: 16px; border-radius: 16px 16px 0 0;">
      <strong>🤖 Trợ lý mua sắm AI</strong>
    </div>
    <div id="chat-messages" style="flex:1; overflow-y:auto; padding: 16px;"></div>
    <div style="padding: 12px; border-top: 1px solid #e2e8f0; display: flex; gap: 8px;">
      <input id="user-input" placeholder="Hỏi về sản phẩm..." 
        style="flex:1; padding: 8px 12px; border: 1px solid #cbd5e1; border-radius: 8px; outline:none;"/>
      <button onclick="sendMessage()" 
        style="background: #0ea5e9; color: white; border:none; padding: 8px 16px; border-radius: 8px; cursor:pointer;">Gửi</button>
    </div>
  `;
  
  document.body.appendChild(widget);
  
  // Gửi message đến agent backend
  window.sendMessage = async function() {
    const input = document.getElementById('user-input');
    const messages = document.getElementById('chat-messages');
    const userMsg = input.value.trim();
    if (!userMsg) return;
    
    // Hiển thị message của user
    messages.innerHTML += `<div style="text-align:right; margin: 8px 0;">
      <span style="background:#0ea5e9; color:white; padding:8px 12px; border-radius:12px; display:inline-block;">${userMsg}</span>
    </div>`;
    input.value = '';
    
    // Gọi agent API
    const response = await fetch('/api/agent/chat', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify({ 
        message: userMsg,
        user_id: localStorage.getItem('user_id') || 'anonymous',
        page: window.location.pathname
      })
    });
    
    const data = await response.json();
    messages.innerHTML += `<div style="margin: 8px 0;">
      <span style="background:#f1f5f9; padding:8px 12px; border-radius:12px; display:inline-block;">${data.reply}</span>
    </div>`;
    messages.scrollTop = messages.scrollHeight;
  };
})();

def should_escalate(action_type: str, amount: float) -> bool:
    """Kiểm tra xem action có cần human approval không"""
    HIGH_RISK_ACTIONS = ["refund", "cancel_order", "apply_discount"]
    
    if action_type in HIGH_RISK_ACTIONS:
        if amount > 500_000:  # Trên 500k VNĐ cần duyệt
            return True
    return False

def handle_agent_action(action_type: str, params: dict):
    if should_escalate(action_type, params.get("amount", 0)):
        # Tạo ticket cho support team
        create_support_ticket(
            action=action_type,
            params=params,
            escalation_reason="Vượt ngưỡng tự động xử lý"
        )
        return "Mình đã chuyển yêu cầu này đến team hỗ trợ. Bạn sẽ nhận phản hồi trong 15 phút."
    
    # Xử lý tự động nếu low-risk
    return execute_action(action_type, params)