main.py

from fastapi import FastAPI, UploadFile, File, Form, HTTPException
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Optional, List, Dict
from PIL import Image
import io
import numpy as np
import os
from datetime import datetime
from pymongo import MongoClient
from huggingface_hub import InferenceClient

from embedding_service import JinaClipEmbeddingService
from qdrant_service import QdrantVectorService
from advanced_rag import AdvancedRAG
from cag_service import CAGService
from pdf_parser import PDFIndexer
from multimodal_pdf_parser import MultimodalPDFIndexer
from conversation_service import ConversationService
from tools_service import ToolsService

# Initialize FastAPI app
app = FastAPI(
    title="Event Social Media Embeddings & ChatbotRAG API",
    description="API để embeddings, search và ChatbotRAG với Jina CLIP v2 + Qdrant + MongoDB + LLM",
    version="2.0.0"
)

# CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Initialize services
print("Initializing services...")
embedding_service = JinaClipEmbeddingService(model_path="jinaai/jina-clip-v2")

collection_name = os.getenv("COLLECTION_NAME", "event_social_media")
qdrant_service = QdrantVectorService(
    collection_name=collection_name,
    vector_size=embedding_service.get_embedding_dimension()
)
print(f"✓ Qdrant collection: {collection_name}")

# MongoDB connection
mongodb_uri = os.getenv("MONGODB_URI", "mongodb+srv://truongtn7122003:7KaI9OT5KTUxWjVI@truongtn7122003.xogin4q.mongodb.net/")
mongo_client = MongoClient(mongodb_uri)
db = mongo_client[os.getenv("MONGODB_DB_NAME", "chatbot_rag")]
documents_collection = db["documents"]
chat_history_collection = db["chat_history"]
print("✓ MongoDB connected")

# Hugging Face token
hf_token = os.getenv("HUGGINGFACE_TOKEN")
if hf_token:
    print("✓ Hugging Face token configured")

# Initialize Advanced RAG (Best Case 2025)
advanced_rag = AdvancedRAG(
    embedding_service=embedding_service,
    qdrant_service=qdrant_service
)
print("✓ Advanced RAG pipeline initialized (with Cross-Encoder)")

# Initialize CAG Service (Semantic Cache)
try:
    cag_service = CAGService(
        embedding_service=embedding_service,
        cache_collection="semantic_cache",
        vector_size=embedding_service.get_embedding_dimension(),
        similarity_threshold=0.9,
        ttl_hours=24
    )
    print("✓ CAG Service initialized (Semantic Caching enabled)")
except Exception as e:
    print(f"Warning: CAG Service initialization failed: {e}")
    print("Continuing without semantic caching...")
    cag_service = None

# Initialize PDF Indexer
pdf_indexer = PDFIndexer(
    embedding_service=embedding_service,
    qdrant_service=qdrant_service,
    documents_collection=documents_collection
)
print("✓ PDF Indexer initialized")

# Initialize Multimodal PDF Indexer
multimodal_pdf_indexer = MultimodalPDFIndexer(
    embedding_service=embedding_service,
    qdrant_service=qdrant_service,
    documents_collection=documents_collection
)
print("✓ Multimodal PDF Indexer initialized")

# Initialize Conversation Service
conversations_collection = db["conversations"]
conversation_service = ConversationService(conversations_collection, max_history=10)
print("✓ Conversation Service initialized")

# Initialize Tools Service
tools_service = ToolsService(base_url="https://www.festavenue.site")
print("✓ Tools Service initialized (Function Calling enabled)")

print("✓ Services initialized successfully")


# Pydantic models for embeddings
class SearchRequest(BaseModel):
    text: Optional[str] = None
    limit: int = 10
    score_threshold: Optional[float] = None
    text_weight: float = 0.5
    image_weight: float = 0.5


class SearchResponse(BaseModel):
    id: str
    confidence: float
    metadata: dict


class IndexResponse(BaseModel):
    success: bool
    id: str
    message: str


# Pydantic models for ChatbotRAG
class ChatRequest(BaseModel):
    message: str
    session_id: Optional[str] = None  # Multi-turn conversation
    use_rag: bool = True
    top_k: int = 3
    system_message: Optional[str] = """Bạn là trợ lý AI chuyên biệt cho hệ thống quản lý sự kiện và bán vé. 
Vai trò của bạn là trả lời các câu hỏi CHÍNH XÁC dựa trên dữ liệu được cung cấp từ hệ thống.

Quy tắc tuyệt đối:
- CHỈ trả lời câu hỏi liên quan đến: events, social media posts, PDFs đã upload, và dữ liệu trong knowledge base
- KHÔNG trả lời câu hỏi ngoài phạm vi (tin tức, thời tiết, toán học, lập trình, tư vấn cá nhân, v.v.)
- Nếu câu hỏi nằm ngoài phạm vi: BẮT BUỘC trả lời "Chúng tôi không thể trả lời câu hỏi này vì nó nằm ngoài vùng application xử lí."
- Luôn ưu tiên thông tin từ context được cung cấp"""
    max_tokens: int = 512
    temperature: float = 0.7
    top_p: float = 0.95
    hf_token: Optional[str] = None
    # Advanced RAG options
    use_advanced_rag: bool = True
    use_query_expansion: bool = True
    use_reranking: bool = False  # Disabled - Cross-Encoder not good for Vietnamese
    use_compression: bool = True
    score_threshold: float = 0.5
    # Function calling
    enable_tools: bool = True  # Enable API tool calling


class ChatResponse(BaseModel):
    response: str
    context_used: List[Dict]
    timestamp: str
    rag_stats: Optional[Dict] = None  # Stats from advanced RAG pipeline
    session_id: str  # NEW: Session identifier for multi-turn
    tool_calls: Optional[List[Dict]] = None  # NEW: Track API calls made


class AddDocumentRequest(BaseModel):
    text: str
    metadata: Optional[Dict] = None


class AddDocumentResponse(BaseModel):
    success: bool
    doc_id: str
    message: str


@app.get("/")
async def root():
    """Health check endpoint with comprehensive API documentation"""
    return {
        "status": "running",
        "service": "ChatbotRAG API",
        "version": "2.0.0",
        "vector_db": "Qdrant",
        "document_db": "MongoDB",        
        "endpoints": {
            "chatbot_rag": {
                "API endpoint": "https://minhvtt-ChatbotRAG.hf.space/",
                "POST /chat": {
                    "description": "Chat với AI sử dụng RAG (Retrieval-Augmented Generation)",
                    "request": {
                        "method": "POST",
                        "content_type": "application/json",
                        "body": {
                            "message": "string (required) - User message/question",
                            "use_rag": "boolean (optional, default: true) - Enable RAG context retrieval",
                            "top_k": "integer (optional, default: 3) - Number of context documents to retrieve",
                            "system_message": "string (optional) - Custom system prompt",
                            "max_tokens": "integer (optional, default: 512) - Max response length",
                            "temperature": "float (optional, default: 0.7, range: 0-1) - Creativity level",
                            "top_p": "float (optional, default: 0.95) - Nucleus sampling",
                            "hf_token": "string (optional) - Hugging Face token (fallback to env)"
                        }
                    },
                    "response": {
                        "response": "string - AI generated response",
                        "context_used": [
                            {
                                "id": "string - Document ID",
                                "confidence": "float - Relevance score",
                                "metadata": {
                                    "text": "string - Retrieved context"
                                }
                            }
                        ],
                        "timestamp": "string - ISO 8601 timestamp"
                    },
                    "example_request": {
                        "message": "Dao có nguy hiểm không?",
                        "use_rag": True,
                        "top_k": 3,
                        "temperature": 0.7
                    },
                    "example_response": {
                        "response": "Dựa trên thông tin trong database, dao được phân loại là vũ khí nguy hiểm. Dao sắc có thể gây thương tích nghiêm trọng nếu không sử dụng đúng cách. Cần tuân thủ các quy định an toàn khi sử dụng.",
                        "context_used": [
                            {
                                "id": "68a3fc14c853d7621e8977b5",
                                "confidence": 0.92,
                                "metadata": {
                                    "text": "Vũ khí"
                                }
                            },
                            {
                                "id": "68a3fc4cc853d7621e8977b6",
                                "confidence": 0.85,
                                "metadata": {
                                    "text": "Con dao sắc"
                                }
                            }
                        ],
                        "timestamp": "2025-10-13T10:30:45.123456"
                    },
                    "notes": [
                        "RAG retrieves relevant context from vector DB before generating response",
                        "LLM uses context to provide accurate, grounded answers",
                        "Requires HUGGINGFACE_TOKEN environment variable or hf_token in request"
                    ]
                },
                "POST /documents": {
                    "description": "Add document to knowledge base for RAG",
                    "request": {
                        "method": "POST",
                        "content_type": "application/json",
                        "body": {
                            "text": "string (required) - Document text content",
                            "metadata": "object (optional) - Additional metadata (source, category, etc.)"
                        }
                    },
                    "response": {
                        "success": "boolean",
                        "doc_id": "string - MongoDB ObjectId",
                        "message": "string - Status message"
                    },
                    "example_request": {
                        "text": "Để tạo event mới: Click nút 'Tạo Event' ở góc trên bên phải màn hình. Điền thông tin sự kiện bao gồm tên, ngày giờ, địa điểm. Click Lưu để hoàn tất.",
                        "metadata": {
                            "source": "user_guide.pdf",
                            "section": "create_event",
                            "page": 5,
                            "category": "tutorial"
                        }
                    },
                    "example_response": {
                        "success": True,
                        "doc_id": "67a9876543210fedcba98765",
                        "message": "Document added successfully with ID: 67a9876543210fedcba98765"
                    }
                },
                "POST /rag/search": {
                    "description": "Search in knowledge base (similar to /search/text but for RAG documents)",
                    "request": {
                        "method": "POST",
                        "content_type": "multipart/form-data",
                        "body": {
                            "query": "string (required) - Search query",
                            "top_k": "integer (optional, default: 5) - Number of results",
                            "score_threshold": "float (optional, default: 0.5) - Minimum relevance score"
                        }
                    },
                    "response": [
                        {
                            "id": "string",
                            "confidence": "float",
                            "metadata": {
                                "text": "string",
                                "source": "string"
                            }
                        }
                    ],
                    "example_request": {
                        "query": "cách tạo sự kiện mới",
                        "top_k": 3,
                        "score_threshold": 0.6
                    }
                },
                "GET /history": {
                    "description": "Get chat conversation history",
                    "request": {
                        "method": "GET",
                        "query_params": {
                            "limit": "integer (optional, default: 10) - Number of messages",
                            "skip": "integer (optional, default: 0) - Pagination offset"
                        }
                    },
                    "response": {
                        "history": [
                            {
                                "user_message": "string",
                                "assistant_response": "string",
                                "context_used": "array",
                                "timestamp": "string - ISO 8601"
                            }
                        ],
                        "total": "integer - Total messages count"
                    },
                    "example_request": "GET /history?limit=5&skip=0",
                    "example_response": {
                        "history": [
                            {
                                "user_message": "Dao có nguy hiểm không?",
                                "assistant_response": "Dao được phân loại là vũ khí...",
                                "context_used": [],
                                "timestamp": "2025-10-13T10:30:45.123456"
                            }
                        ],
                        "total": 15
                    }
                },
                "DELETE /documents/{doc_id}": {
                    "description": "Delete document from knowledge base",
                    "request": {
                        "method": "DELETE",
                        "path_params": {
                            "doc_id": "string - MongoDB ObjectId"
                        }
                    },
                    "response": {
                        "success": "boolean",
                        "message": "string"
                    }
                }
            }
        },
        "usage_examples": {
            "curl_chat": "curl -X POST 'http://localhost:8000/chat' -H 'Content-Type: application/json' -d '{\"message\": \"Dao có nguy hiểm không?\", \"use_rag\": true}'",
            "python_chat": """
import requests

response = requests.post(
    'http://localhost:8000/chat',
    json={
        'message': 'Nút tạo event ở đâu?',
        'use_rag': True,
        'top_k': 3
    }
)
print(response.json()['response'])
            """
        },
        "authentication": {
            "embeddings_apis": "No authentication required",
            "chat_api": "Requires HUGGINGFACE_TOKEN (env variable or request body)"
        },
        "rate_limits": {
            "embeddings": "No limit",
            "chat_with_llm": "Limited by Hugging Face API (free tier: ~1000 requests/hour)"
        },
        "error_codes": {
            "400": "Bad Request - Missing required fields or invalid input",
            "401": "Unauthorized - Invalid Hugging Face token",
            "404": "Not Found - Document ID not found",
            "500": "Internal Server Error - Server or database error"
        },
        "links": {
            "docs": "http://localhost:8000/docs",
            "redoc": "http://localhost:8000/redoc",
            "openapi": "http://localhost:8000/openapi.json"
        }
    }

@app.post("/index", response_model=IndexResponse)
async def index_data(
    id: str = Form(...),
    text: str = Form(...),
    image: Optional[UploadFile] = File(None)
):
    """
    Index data vào vector database

    Body:
    - id: Document ID (event ID, post ID, etc.)
    - text: Text content (tiếng Việt supported)
    - image: Image file (optional)

    Returns:
    - success: True/False
    - id: Document ID
    - message: Status message
    """
    try:
        # Prepare embeddings
        text_embedding = None
        image_embedding = None

        # Encode text (tiếng Việt)
        if text and text.strip():
            text_embedding = embedding_service.encode_text(text)

        # Encode image nếu có
        if image:
            image_bytes = await image.read()
            pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
            image_embedding = embedding_service.encode_image(pil_image)

        # Combine embeddings
        if text_embedding is not None and image_embedding is not None:
            # Average của text và image embeddings
            combined_embedding = np.mean([text_embedding, image_embedding], axis=0)
        elif text_embedding is not None:
            combined_embedding = text_embedding
        elif image_embedding is not None:
            combined_embedding = image_embedding
        else:
            raise HTTPException(status_code=400, detail="Phải cung cấp ít nhất text hoặc image")

        # Normalize
        combined_embedding = combined_embedding / np.linalg.norm(combined_embedding, axis=1, keepdims=True)

        # Index vào Qdrant
        metadata = {
            "text": text,
            "has_image": image is not None,
            "image_filename": image.filename if image else None
        }

        result = qdrant_service.index_data(
            doc_id=id,
            embedding=combined_embedding,
            metadata=metadata
        )

        return IndexResponse(
            success=True,
            id=result["original_id"],  # Trả về MongoDB ObjectId
            message=f"Đã index thành công document {result['original_id']} (Qdrant UUID: {result['qdrant_id']})"
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi index: {str(e)}")


@app.post("/search", response_model=List[SearchResponse])
async def search(
    text: Optional[str] = Form(None),
    image: Optional[UploadFile] = File(None),
    limit: int = Form(10),
    score_threshold: Optional[float] = Form(None),
    text_weight: float = Form(0.5),
    image_weight: float = Form(0.5)
):
    """
    Search similar documents bằng text và/hoặc image

    Body:
    - text: Query text (tiếng Việt supported)
    - image: Query image (optional)
    - limit: Số lượng kết quả (default: 10)
    - score_threshold: Minimum confidence score (0-1)
    - text_weight: Weight cho text search (default: 0.5)
    - image_weight: Weight cho image search (default: 0.5)

    Returns:
    - List of results với id, confidence, và metadata
    """
    try:
        # Prepare query embeddings
        text_embedding = None
        image_embedding = None

        # Encode text query
        if text and text.strip():
            text_embedding = embedding_service.encode_text(text)

        # Encode image query
        if image:
            image_bytes = await image.read()
            pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
            image_embedding = embedding_service.encode_image(pil_image)

        # Validate input
        if text_embedding is None and image_embedding is None:
            raise HTTPException(status_code=400, detail="Phải cung cấp ít nhất text hoặc image để search")

        # Hybrid search với Qdrant
        results = qdrant_service.hybrid_search(
            text_embedding=text_embedding,
            image_embedding=image_embedding,
            text_weight=text_weight,
            image_weight=image_weight,
            limit=limit,
            score_threshold=score_threshold,
            ef=256  # High accuracy search
        )

        # Format response
        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi search: {str(e)}")


@app.post("/search/text", response_model=List[SearchResponse])
async def search_by_text(
    text: str = Form(...),
    limit: int = Form(10),
    score_threshold: Optional[float] = Form(None)
):
    """
    Search chỉ bằng text (tiếng Việt)

    Body:
    - text: Query text (tiếng Việt)
    - limit: Số lượng kết quả
    - score_threshold: Minimum confidence score

    Returns:
    - List of results
    """
    try:
        # Encode text
        text_embedding = embedding_service.encode_text(text)

        # Search
        results = qdrant_service.search(
            query_embedding=text_embedding,
            limit=limit,
            score_threshold=score_threshold,
            ef=256
        )

        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi search: {str(e)}")


@app.post("/search/image", response_model=List[SearchResponse])
async def search_by_image(
    image: UploadFile = File(...),
    limit: int = Form(10),
    score_threshold: Optional[float] = Form(None)
):
    """
    Search chỉ bằng image

    Body:
    - image: Query image
    - limit: Số lượng kết quả
    - score_threshold: Minimum confidence score

    Returns:
    - List of results
    """
    try:
        # Encode image
        image_bytes = await image.read()
        pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
        image_embedding = embedding_service.encode_image(pil_image)

        # Search
        results = qdrant_service.search(
            query_embedding=image_embedding,
            limit=limit,
            score_threshold=score_threshold,
            ef=256
        )

        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi search: {str(e)}")


@app.delete("/delete/{doc_id}")
async def delete_document(doc_id: str):
    """
    Delete document by ID (MongoDB ObjectId hoặc UUID)

    Args:
    - doc_id: Document ID to delete

    Returns:
    - Success message
    """
    try:
        qdrant_service.delete_by_id(doc_id)
        return {"success": True, "message": f"Đã xóa document {doc_id}"}
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi xóa: {str(e)}")


@app.get("/document/{doc_id}")
async def get_document(doc_id: str):
    """
    Get document by ID (MongoDB ObjectId hoặc UUID)

    Args:
    - doc_id: Document ID (MongoDB ObjectId)

    Returns:
    - Document data
    """
    try:
        doc = qdrant_service.get_by_id(doc_id)
        if doc:
            return {
                "success": True,
                "data": doc
            }
        raise HTTPException(status_code=404, detail=f"Không tìm thấy document {doc_id}")
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi get document: {str(e)}")


@app.get("/stats")
async def get_stats():
    """
    Lấy thông tin thống kê collection

    Returns:
    - Collection statistics
    """
    try:
        info = qdrant_service.get_collection_info()
        return info
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Lỗi khi lấy stats: {str(e)}")


# ============================================
# ChatbotRAG Endpoints
# ============================================

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """
    Chat endpoint với RAG

    Body:
    - message: User message
    - use_rag: Enable RAG retrieval (default: true)
    - top_k: Number of documents to retrieve (default: 3)
    - system_message: System prompt (optional)
    - max_tokens: Max tokens for response (default: 512)
    - temperature: Temperature for generation (default: 0.7)
    - hf_token: Hugging Face token (optional, sẽ dùng env nếu không truyền)

    Returns:
    - response: Generated response
    - context_used: Retrieved context documents
    - timestamp: Response timestamp
    """
    try:
        # Retrieve context if RAG enabled
        context_used = []
        rag_stats = None
        
        if request.use_rag:
            if request.use_advanced_rag:
                # Use Advanced RAG Pipeline (Best Case 2025)
                hf_client = None
                if request.hf_token or hf_token:
                    hf_client = InferenceClient(token=request.hf_token or hf_token)
                
                documents, stats = advanced_rag.hybrid_rag_pipeline(
                    query=request.message,
                    top_k=request.top_k,
                    score_threshold=request.score_threshold,
                    use_reranking=request.use_reranking,
                    use_compression=request.use_compression,
                    use_query_expansion=request.use_query_expansion,
                    max_context_tokens=500,
                    hf_client=hf_client
                )
                
                # Convert to dict format
                context_used = [
                    {
                        "id": doc.id,
                        "confidence": doc.confidence,
                        "metadata": doc.metadata
                    }
                    for doc in documents
                ]
                rag_stats = stats
                
                # Format context using Advanced RAG
                context_text = advanced_rag.format_context_for_llm(documents)
            else:
                # Basic RAG (fallback)
                query_embedding = embedding_service.encode_text(request.message)
                results = qdrant_service.search(
                    query_embedding=query_embedding,
                    limit=request.top_k,
                    score_threshold=request.score_threshold
                )
                context_used = results
                
                context_text = "\n\nRelevant Context:\n"
                for i, doc in enumerate(context_used, 1):
                    doc_text = doc["metadata"].get("text", "")
                    if not doc_text:
                        doc_text = " ".join(doc["metadata"].get("texts", []))
                    confidence = doc["confidence"]
                    context_text += f"\n[{i}] (Confidence: {confidence:.2f})\n{doc_text}\n"

        # Build system message with context
        if request.use_rag and context_used:
            if request.use_advanced_rag:
                # Use Advanced RAG prompt builder
                system_message = advanced_rag.build_rag_prompt(
                    query=request.message,
                    context=context_text,
                    system_message=request.system_message
                )
            else:
                # Basic prompt
                # Basic prompt with better instructions
                system_message = f"""{request.system_message}

{context_text}

HƯỚNG DẪN:
- Sử dụng thông tin từ context trên để trả lời câu hỏi.
- Trả lời tự nhiên, thân thiện, không copy nguyên văn.
- Nếu tìm thấy sự kiện, hãy tóm tắt các thông tin quan trọng nhất.
"""
        else:
            system_message = request.system_message

        # Use token from request or fallback to env
        token = request.hf_token or hf_token
        # Generate response
        if not token:
            response = f"""[LLM Response Placeholder]

Context retrieved: {len(context_used)} documents
User question: {request.message}

To enable actual LLM generation:
1. Set HUGGINGFACE_TOKEN environment variable, OR
2. Pass hf_token in request body

Example:
{{
  "message": "Your question",
  "hf_token": "hf_xxxxxxxxxxxxx"
}}
"""
        else:
            try:
                client = InferenceClient(
                    token=hf_token,
                    model="openai/gpt-oss-20b"
                )

                # Build messages - luôn dùng cấu trúc chuẩn
                # System = instructions + context, User = query
                messages = [
                    {"role": "system", "content": system_message},
                    {"role": "user", "content": request.message}
                ]

                # Generate response
                response = ""
                for msg in client.chat_completion(
                    messages,
                    max_tokens=request.max_tokens,
                    stream=True,
                    temperature=request.temperature,
                    top_p=request.top_p,
                ):
                    choices = msg.choices
                    if len(choices) and choices[0].delta.content:
                        response += choices[0].delta.content

            except Exception as e:
                response = f"Error generating response with LLM: {str(e)}\n\nContext was retrieved successfully, but LLM generation failed."

        # Save to history
        chat_data = {
            "user_message": request.message,
            "assistant_response": response,
            "context_used": context_used,
            "timestamp": datetime.utcnow()
        }
        chat_history_collection.insert_one(chat_data)

        return ChatResponse(
            response=response,
            context_used=context_used,
            timestamp=datetime.utcnow().isoformat(),
            rag_stats=rag_stats
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.post("/documents", response_model=AddDocumentResponse)
async def add_document(request: AddDocumentRequest):
    """
    Add document to knowledge base

    Body:
    - text: Document text
    - metadata: Additional metadata (optional)

    Returns:
    - success: True/False
    - doc_id: MongoDB document ID
    - message: Status message
    """
    try:
        # Save to MongoDB
        doc_data = {
            "text": request.text,
            "metadata": request.metadata or {},
            "created_at": datetime.utcnow()
        }
        result = documents_collection.insert_one(doc_data)
        doc_id = str(result.inserted_id)

        # Generate embedding
        embedding = embedding_service.encode_text(request.text)

        # Index to Qdrant
        qdrant_service.index_data(
            doc_id=doc_id,
            embedding=embedding,
            metadata={
                "text": request.text,
                "source": "api",
                **(request.metadata or {})
            }
        )

        return AddDocumentResponse(
            success=True,
            doc_id=doc_id,
            message=f"Document added successfully with ID: {doc_id}"
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.post("/rag/search", response_model=List[SearchResponse])
async def rag_search(
    query: str = Form(...),
    top_k: int = Form(5),
    score_threshold: Optional[float] = Form(0.5)
):
    """
    Search in knowledge base

    Body:
    - query: Search query
    - top_k: Number of results (default: 5)
    - score_threshold: Minimum score (default: 0.5)

    Returns:
    - results: List of matching documents
    """
    try:
        # Generate query embedding
        query_embedding = embedding_service.encode_text(query)

        # Search in Qdrant
        results = qdrant_service.search(
            query_embedding=query_embedding,
            limit=top_k,
            score_threshold=score_threshold
        )

        return [
            SearchResponse(
                id=result["id"],
                confidence=result["confidence"],
                metadata=result["metadata"]
            )
            for result in results
        ]

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.get("/history")
async def get_history(limit: int = 10, skip: int = 0):
    """
    Get chat history

    Query params:
    - limit: Number of messages to return (default: 10)
    - skip: Number of messages to skip (default: 0)

    Returns:
    - history: List of chat messages
    """
    try:
        history = list(
            chat_history_collection
            .find({}, {"_id": 0})
            .sort("timestamp", -1)
            .skip(skip)
            .limit(limit)
        )

        # Convert datetime to string
        for msg in history:
            if "timestamp" in msg:
                msg["timestamp"] = msg["timestamp"].isoformat()

        return {
            "history": history,
            "total": chat_history_collection.count_documents({})
        }

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


@app.delete("/documents/{doc_id}")
async def delete_document_from_kb(doc_id: str):
    """
    Delete document from knowledge base

    Args:
    - doc_id: Document ID (MongoDB ObjectId)

    Returns:
    - success: True/False
    - message: Status message
    """
    try:
        # Delete from MongoDB
        result = documents_collection.delete_one({"_id": doc_id})

        # Delete from Qdrant
        if result.deleted_count > 0:
            qdrant_service.delete_by_id(doc_id)
            return {"success": True, "message": f"Document {doc_id} deleted from knowledge base"}
        else:
            raise HTTPException(status_code=404, detail=f"Document {doc_id} not found")

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        log_level="info"
    )