Initial commit of the MentorMe AI Recommendation Server, including core application structure, environment configuration, Docker setup, and essential services for mentor recommendations and health checks.

.env.example

@@ -0,0 +1,21 @@
+# Pinecone Configuration
+PINECONE_API_KEY=your_pinecone_api_key_here
+PINECONE_INDEX=mentorme-mentors
+PINECONE_ENVIRONMENT=us-east-1-aws
+PINECONE_DIMENSION=1024
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+DEBUG=False
+
+# CORS Configuration
+CORS_ORIGINS=http://localhost:8080
+
+# Model Configuration
+BGE_MODEL_NAME=BAAI/bge-m3
+USE_FP16=True
+
+# Recommendation Configuration
+RECOMMENDATION_TOP_K=30
+RECOMMENDATION_FINAL_COUNT=8

.gitignore

@@ -0,0 +1,49 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# Environment variables
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Model cache (optional - can be large)
+# .cache/
+
+# Logs
+*.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+
+

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port (Hugging Face Spaces will set PORT env var)
+EXPOSE 7860
+
+# Run the application (PORT will be set by Hugging Face Spaces)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -1,8 +1,8 @@
 ---
-title: Mentorme
-emoji: 😻
-colorFrom: green
-colorTo: yellow
+title: Ai Service
+emoji: ⚡
+colorFrom: indigo
+colorTo: indigo
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,91 @@
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+import os
+import logging
+
+from config.settings import get_settings
+from routers import mentors, recommend, health
+from services.embedding_service import EmbeddingService
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+settings = get_settings()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("Starting application...")
+    try:
+        logger.info("Loading embedding service...")
+        embedding_service = EmbeddingService()
+        app.state.embedding_service = embedding_service
+        logger.info("Application started successfully")
+    except Exception as e:
+        logger.error(f"Failed to start application: {str(e)}", exc_info=True)
+        raise
+    yield
+    logger.info("Shutting down application...")
+    if hasattr(app.state, 'embedding_service'):
+        del app.state.embedding_service
+
+app = FastAPI(
+    title="MentorMe AI Recommendation Server",
+    description="AI-powered mentor-mentee recommendation using Vietnamese_Embedding and Pinecone",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+cors_origins = settings.CORS_ORIGINS
+if not cors_origins:
+    cors_origins = ["*"]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router, prefix="/api/v1", tags=["Health"])
+app.include_router(mentors.router, prefix="/api/v1", tags=["Mentors"])
+app.include_router(recommend.router, prefix="/api/v1", tags=["Recommendations"])
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    logger.info(f"Incoming request: {request.method} {request.url}")
+    logger.debug(f"Headers: {dict(request.headers)}")
+    response = await call_next(request)
+    logger.info(f"Response status: {response.status_code}")
+    return response
+
+@app.get("/")
+async def root():
+    return {
+        "message": "MentorMe AI Recommendation Server",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": {
+            "health": "/api/v1/health",
+            "upsert_mentor": "/api/v1/mentors/upsert",
+            "recommend": "/api/v1/recommend"
+        }
+    }
+
+@app.post("/test-post")
+async def test_post(request: Request):
+    logger.info(f"Test POST received: {request.method} {request.url}")
+    logger.info(f"Headers: {dict(request.headers)}")
+    body = await request.body()
+    logger.info(f"Body: {body}")
+    return {
+        "message": "POST request received successfully",
+        "method": request.method,
+        "url": str(request.url),
+        "headers": dict(request.headers)
+    }
+

config/settings.py

@@ -0,0 +1,71 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import field_validator
+from typing import List, Union
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        case_sensitive=True,
+        extra="ignore"
+    )
+    
+    PINECONE_API_KEY: str = ""
+    PINECONE_INDEX: str = "mentorme-mentors"
+    PINECONE_ENVIRONMENT: str = "us-east-1-aws"
+    PINECONE_DIMENSION: int = 1024
+    
+    HOST: str = "0.0.0.0"
+    PORT: int = int(os.getenv("PORT", "7860"))
+    DEBUG: bool = False
+    
+    EMBEDDING_MODEL_NAME: str = "AITeamVN/Vietnamese_Embedding"
+    USE_FP16: bool = True
+    
+    RECOMMENDATION_TOP_K: int = 30
+    RECOMMENDATION_RERANK_K: int = 15
+    RECOMMENDATION_FINAL_COUNT: int = 6
+    SEMANTIC_WEIGHT: float = 0.7
+    RULE_BASED_WEIGHT: float = 0.3
+    
+    @property
+    def CORS_ORIGINS(self) -> List[str]:
+        cors_str = os.getenv("CORS_ORIGINS", "*")
+        if cors_str == "*":
+            return ["*"]
+        return [origin.strip() for origin in cors_str.split(",") if origin.strip()]
+    
+    @field_validator("DEBUG", "USE_FP16", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Union[str, bool]) -> bool:
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes", "on")
+        return bool(v)
+    
+    @field_validator("PORT", "PINECONE_DIMENSION", "RECOMMENDATION_TOP_K", "RECOMMENDATION_RERANK_K", "RECOMMENDATION_FINAL_COUNT", mode="before")
+    @classmethod
+    def parse_int(cls, v: Union[str, int]) -> int:
+        if isinstance(v, str):
+            return int(v)
+        return v
+    
+    @field_validator("SEMANTIC_WEIGHT", "RULE_BASED_WEIGHT", mode="before")
+    @classmethod
+    def parse_float(cls, v: Union[str, float]) -> float:
+        if isinstance(v, str):
+            return float(v)
+        return v
+
+_settings: Settings = None
+
+def get_settings() -> Settings:
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings
+
+
+

main.py

@@ -0,0 +1,57 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+from contextlib import asynccontextmanager
+
+from config.settings import get_settings
+from routers import mentors, recommend, health
+from services.embedding_service import EmbeddingService
+
+settings = get_settings()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    embedding_service = EmbeddingService()
+    app.state.embedding_service = embedding_service
+    yield
+    if hasattr(app.state, 'embedding_service'):
+        del app.state.embedding_service
+
+app = FastAPI(
+    title="MentorMe AI Recommendation Server",
+    description="AI-powered mentor-mentee recommendation using Vietnamese_Embedding and Pinecone",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router, prefix="/api/v1", tags=["Health"])
+app.include_router(mentors.router, prefix="/api/v1", tags=["Mentors"])
+app.include_router(recommend.router, prefix="/api/v1", tags=["Recommendations"])
+
+@app.get("/")
+async def root():
+    return {
+        "message": "MentorMe AI Recommendation Server",
+        "version": "1.0.0",
+        "status": "running"
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=settings.DEBUG,
+        log_level="info"
+    )
+
+
+

models/schemas.py

@@ -0,0 +1,105 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any, Union
+
+class SkillDto(BaseModel):
+    id: Optional[int] = None
+    name: str
+
+class DomainDto(BaseModel):
+    id: Optional[int] = None
+    name: str
+
+class CareerDto(BaseModel):
+    id: Optional[int] = None
+    name: str
+
+class ExperienceDto(BaseModel):
+    company: Optional[str] = None
+    position: Optional[str] = None
+    start_date: Optional[str] = None
+    end_date: Optional[str] = None
+    description: Optional[str] = None
+
+class EducationDto(BaseModel):
+    school: Optional[str] = None
+    degree: Optional[str] = None
+    start_date: Optional[str] = None
+    end_date: Optional[str] = None
+    description: Optional[str] = None
+
+class ScheduleDto(BaseModel):
+    day_of_week: int
+    start_time: str
+    end_time: str
+    is_active: int = 1
+
+class MentorUpsertRequest(BaseModel):
+    mentor_id: int
+    full_name: Optional[str] = None
+    bio: Optional[str] = None
+    career: Optional[Union[CareerDto, Dict[str, Any], str]] = None
+    skills: Optional[List[Union[SkillDto, Dict[str, Any], str]]] = None
+    domains: Optional[List[Union[DomainDto, Dict[str, Any], str]]] = None
+    experiences: Optional[List[Union[ExperienceDto, Dict[str, Any]]]] = None
+    educations: Optional[List[Union[EducationDto, Dict[str, Any]]]] = None
+    rating: Optional[float] = Field(None, ge=0.0, le=5.0)
+    total_ratings: Optional[int] = Field(None, ge=0)
+    session_count: Optional[int] = Field(None, ge=0)
+    available_slots: Optional[int] = Field(None, ge=0)
+    schedules: Optional[List[Union[ScheduleDto, Dict[str, Any]]]] = None
+    career_id: Optional[int] = None
+    skill_ids: Optional[List[int]] = None
+    domain_ids: Optional[List[int]] = None
+    status: Optional[str] = "ACTIVATED"
+    has_availability: Optional[bool] = False
+
+class MentorUpsertResponse(BaseModel):
+    success: bool
+    message: str
+    mentor_id: int
+
+class RecommendationRequest(BaseModel):
+    goals: Optional[str] = None
+    desired_skills: Optional[List[Union[SkillDto, Dict[str, Any], str]]] = None
+    current_skills: Optional[List[Union[SkillDto, Dict[str, Any], str]]] = None
+    interests: Optional[List[Union[DomainDto, Dict[str, Any], str]]] = None
+    domains: Optional[List[Union[DomainDto, Dict[str, Any], str]]] = None
+    availability: Optional[str] = None
+    preferred_availability: Optional[str] = None
+    min_rating: Optional[float] = Field(None, ge=0.0, le=5.0)
+    require_availability: Optional[bool] = False
+    skill_ids: Optional[List[int]] = None
+    domain_ids: Optional[List[int]] = None
+    career_id: Optional[int] = None
+    status: Optional[str] = "ACTIVATED"
+    top_k: Optional[int] = Field(None, ge=1, le=100)
+    final_count: Optional[int] = Field(None, ge=1, le=20)
+
+class RecommendedMentor(BaseModel):
+    mentor_id: str
+    score: float
+    semantic_similarity: float
+    reason: str
+    metadata: Dict[str, Any]
+
+class RecommendationResponse(BaseModel):
+    mentors: List[RecommendedMentor]
+    count: int
+    query_text: Optional[str] = None
+
+class HealthResponse(BaseModel):
+    status: str
+    embedding_model: Dict[str, Any]
+    pinecone_index: Dict[str, Any]
+
+class BatchUpsertRequest(BaseModel):
+    mentors: List[MentorUpsertRequest]
+
+class BatchUpsertResponse(BaseModel):
+    success: bool
+    message: str
+    upserted_count: int
+    failed_count: int
+
+
+

requirements.txt

@@ -0,0 +1,16 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+pydantic-settings==2.1.0
+python-dotenv==1.0.0
+pinecone-client>=3.2.0,<6.0.0
+sentence-transformers>=2.2.0
+torch>=2.0.0
+numpy>=1.24.0
+python-multipart==0.0.6
+transformers>=4.30.0
+accelerate>=0.20.0
+sentencepiece>=0.1.99
+
+
+

routers/health.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter, Request
+from models.schemas import HealthResponse
+from services.embedding_service import EmbeddingService
+from services.pinecone_service import PineconeService
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.get("/health", response_model=HealthResponse)
+async def health_check(request: Request):
+    try:
+        embedding_service: EmbeddingService = request.app.state.embedding_service
+        embedding_info = embedding_service.get_model_info()
+        
+        pinecone_service = PineconeService()
+        pinecone_stats = pinecone_service.get_index_stats()
+        
+        return HealthResponse(
+            status="healthy",
+            embedding_model=embedding_info,
+            pinecone_index=pinecone_stats
+        )
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}")
+        return HealthResponse(
+            status="unhealthy",
+            embedding_model={"error": str(e)},
+            pinecone_index={"error": str(e)}
+        )
+
+
+

routers/mentors.py

@@ -0,0 +1,119 @@
+from fastapi import APIRouter, Request, HTTPException, status
+from models.schemas import (
+    MentorUpsertRequest,
+    MentorUpsertResponse,
+    BatchUpsertRequest,
+    BatchUpsertResponse
+)
+from services.recommendation_service import RecommendationService
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.post("/mentors/upsert", response_model=MentorUpsertResponse)
+async def upsert_mentor(
+    request: Request,
+    mentor_data: MentorUpsertRequest
+):
+    try:
+        logger.info(f"Received upsert request for mentor ID: {mentor_data.mentor_id}")
+        logger.debug(f"Request headers: {dict(request.headers)}")
+        logger.debug(f"Request method: {request.method}")
+        logger.debug(f"Request URL: {request.url}")
+        
+        recommendation_service = RecommendationService()
+        
+        mentor_dict = mentor_data.model_dump()
+        success = recommendation_service.upsert_mentor(mentor_dict)
+        
+        if success:
+            logger.info(f"Successfully upserted mentor ID: {mentor_data.mentor_id}")
+            return MentorUpsertResponse(
+                success=True,
+                message="Mentor upserted successfully",
+                mentor_id=mentor_data.mentor_id
+            )
+        else:
+            logger.error(f"Failed to upsert mentor ID: {mentor_data.mentor_id}")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to upsert mentor"
+            )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error upserting mentor: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to upsert mentor: {str(e)}"
+        )
+
+@router.post("/mentors/batch-upsert", response_model=BatchUpsertResponse)
+async def batch_upsert_mentors(
+    request: Request,
+    batch_data: BatchUpsertRequest
+):
+    try:
+        recommendation_service = RecommendationService()
+        upserted_count = 0
+        failed_count = 0
+        
+        for mentor_data in batch_data.mentors:
+            try:
+                mentor_dict = mentor_data.model_dump()
+                success = recommendation_service.upsert_mentor(mentor_dict)
+                if success:
+                    upserted_count += 1
+                else:
+                    failed_count += 1
+            except Exception as e:
+                logger.error(f"Error upserting mentor {mentor_data.mentor_id}: {str(e)}")
+                failed_count += 1
+        
+        return BatchUpsertResponse(
+            success=True,
+            message=f"Batch upsert completed: {upserted_count} succeeded, {failed_count} failed",
+            upserted_count=upserted_count,
+            failed_count=failed_count
+        )
+    except Exception as e:
+        logger.error(f"Error in batch upsert: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to batch upsert mentors: {str(e)}"
+        )
+
+@router.delete("/mentors/{mentor_id}")
+async def delete_mentor(
+    request: Request,
+    mentor_id: int
+):
+    try:
+        logger.info(f"Received delete request for mentor ID: {mentor_id}")
+        
+        recommendation_service = RecommendationService()
+        success = recommendation_service.delete_mentor(str(mentor_id))
+        
+        if success:
+            logger.info(f"Successfully deleted mentor ID: {mentor_id}")
+            return {
+                "success": True,
+                "message": "Mentor deleted successfully",
+                "mentor_id": mentor_id
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to delete mentor"
+            )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting mentor: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete mentor: {str(e)}"
+        )
+

routers/recommend.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, Request, HTTPException, status
+from models.schemas import RecommendationRequest, RecommendationResponse, RecommendedMentor
+from services.recommendation_service import RecommendationService
+from utils.text_builder import build_mentee_query_text
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.post("/recommend", response_model=RecommendationResponse)
+async def recommend_mentors(
+    request: Request,
+    recommendation_request: RecommendationRequest
+):
+    try:
+        recommendation_service = RecommendationService()
+        
+        mentee_dict = recommendation_request.model_dump(exclude_none=True)
+        query_text = build_mentee_query_text(mentee_dict)
+        
+        recommended = recommendation_service.recommend_mentors(
+            mentee_dict,
+            top_k=recommendation_request.top_k,
+            final_count=recommendation_request.final_count
+        )
+        
+        mentors = [
+            RecommendedMentor(
+                mentor_id=rec["mentor_id"],
+                score=rec["score"],
+                semantic_similarity=rec["semantic_similarity"],
+                reason=rec["reason"],
+                metadata=rec["metadata"]
+            )
+            for rec in recommended
+        ]
+        
+        return RecommendationResponse(
+            mentors=mentors,
+            count=len(mentors),
+            query_text=query_text
+        )
+    except Exception as e:
+        logger.error(f"Error recommending mentors: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to recommend mentors: {str(e)}"
+        )
+
+
+

services/embedding_service.py

@@ -0,0 +1,107 @@
+import torch
+from sentence_transformers import SentenceTransformer
+import logging
+from typing import List, Union
+from config.settings import get_settings
+
+logger = logging.getLogger(__name__)
+
+class EmbeddingService:
+    _instance = None
+    _model = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(EmbeddingService, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if EmbeddingService._model is None:
+            self._load_model()
+    
+    def _load_model(self):
+        settings = get_settings()
+        try:
+            logger.info(f"Loading embedding model: {settings.EMBEDDING_MODEL_NAME}")
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            logger.info(f"Using device: {device}")
+            
+            EmbeddingService._model = SentenceTransformer(
+                settings.EMBEDDING_MODEL_NAME,
+                device=device
+            )
+            
+            EmbeddingService._model.max_seq_length = 2048
+            
+            logger.info("Embedding model loaded successfully")
+        except Exception as e:
+            logger.error(f"Failed to load embedding model: {str(e)}")
+            raise
+    
+    def encode(
+        self,
+        texts: Union[str, List[str]],
+        is_query: bool = False,
+        batch_size: int = 32,
+        max_length: int = 2048
+    ) -> Union[List[float], List[List[float]]]:
+        if EmbeddingService._model is None:
+            raise RuntimeError("Embedding model not loaded")
+        
+        if isinstance(texts, str):
+            texts = [texts]
+            single_text = True
+        else:
+            single_text = False
+        
+        if not texts:
+            raise ValueError("Texts cannot be empty")
+        
+        try:
+            embeddings = EmbeddingService._model.encode(
+                texts,
+                batch_size=batch_size,
+                show_progress_bar=False,
+                convert_to_numpy=True,
+                normalize_embeddings=False
+            )
+            
+            expected_dim = 1024
+            if single_text:
+                embedding_list = embeddings[0].tolist()
+                if len(embedding_list) != expected_dim:
+                    logger.warning(f"Embedding dimension mismatch: expected {expected_dim}, got {len(embedding_list)}")
+                return embedding_list
+            
+            result = []
+            for emb in embeddings:
+                emb_list = emb.tolist()
+                if len(emb_list) != expected_dim:
+                    logger.warning(f"Embedding dimension mismatch: expected {expected_dim}, got {len(emb_list)}")
+                result.append(emb_list)
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error encoding texts: {str(e)}")
+            raise
+    
+    def get_model_info(self) -> dict:
+        settings = get_settings()
+        dimension = 1024
+        
+        if EmbeddingService._model is not None:
+            try:
+                test_embedding = EmbeddingService._model.encode(["test"], convert_to_numpy=True)
+                dimension = len(test_embedding[0])
+            except Exception as e:
+                logger.warning(f"Could not determine model dimension: {str(e)}")
+        
+        return {
+            "model_name": settings.EMBEDDING_MODEL_NAME,
+            "dimension": dimension,
+            "device": "cuda" if torch.cuda.is_available() else "cpu",
+            "max_seq_length": EmbeddingService._model.max_seq_length if EmbeddingService._model else 2048
+        }
+
+
+

services/pinecone_service.py

@@ -0,0 +1,161 @@
+from pinecone import Pinecone, ServerlessSpec
+from typing import List, Dict, Optional, Any
+import logging
+from config.settings import get_settings
+
+logger = logging.getLogger(__name__)
+
+class PineconeService:
+    _instance = None
+    _client = None
+    _index = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(PineconeService, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if PineconeService._client is None:
+            self._initialize()
+    
+    def _initialize(self):
+        settings = get_settings()
+        
+        if not settings.PINECONE_API_KEY:
+            raise ValueError("PINECONE_API_KEY is required")
+        
+        try:
+            PineconeService._client = Pinecone(api_key=settings.PINECONE_API_KEY)
+            
+            index_name = settings.PINECONE_INDEX
+            
+            existing_indexes = [idx.name for idx in PineconeService._client.list_indexes()]
+            
+            if index_name not in existing_indexes:
+                logger.info(f"Creating Pinecone index: {index_name}")
+                PineconeService._client.create_index(
+                    name=index_name,
+                    dimension=settings.PINECONE_DIMENSION,
+                    metric="cosine",
+                    spec=ServerlessSpec(
+                        cloud="aws",
+                        region=settings.PINECONE_ENVIRONMENT
+                    )
+                )
+                logger.info(f"Index {index_name} created successfully")
+            
+            PineconeService._index = PineconeService._client.Index(index_name)
+            logger.info(f"Connected to Pinecone index: {index_name}")
+        except Exception as e:
+            logger.error(f"Failed to initialize Pinecone: {str(e)}")
+            raise
+    
+    def upsert_mentor(
+        self,
+        mentor_id: str,
+        vector: List[float],
+        metadata: Dict[str, Any]
+    ) -> bool:
+        try:
+            settings = get_settings()
+            expected_dim = settings.PINECONE_DIMENSION
+            
+            if len(vector) != expected_dim:
+                error_msg = f"Vector dimension mismatch: expected {expected_dim}, got {len(vector)}"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+            
+            PineconeService._index.upsert(
+                vectors=[{
+                    "id": str(mentor_id),
+                    "values": vector,
+                    "metadata": metadata
+                }]
+            )
+            logger.info(f"Mentor {mentor_id} upserted successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to upsert mentor {mentor_id}: {str(e)}")
+            raise
+    
+    def upsert_mentors_batch(
+        self,
+        vectors: List[Dict[str, Any]]
+    ) -> bool:
+        try:
+            PineconeService._index.upsert(vectors=vectors)
+            logger.info(f"Batch upserted {len(vectors)} mentors")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to batch upsert mentors: {str(e)}")
+            raise
+    
+    def query_similar(
+        self,
+        query_vector: List[float],
+        top_k: int = 30,
+        filter: Optional[Dict[str, Any]] = None,
+        include_metadata: bool = True
+    ) -> List[Dict[str, Any]]:
+        try:
+            settings = get_settings()
+            expected_dim = settings.PINECONE_DIMENSION
+            
+            if len(query_vector) != expected_dim:
+                error_msg = f"Query vector dimension mismatch: expected {expected_dim}, got {len(query_vector)}"
+                logger.error(error_msg)
+                raise ValueError(error_msg)
+            
+            query_response = PineconeService._index.query(
+                vector=query_vector,
+                top_k=top_k,
+                filter=filter,
+                include_metadata=include_metadata
+            )
+            
+            results = []
+            for match in query_response.matches:
+                results.append({
+                    "mentor_id": match.id,
+                    "score": match.score,
+                    "metadata": match.metadata if include_metadata else None
+                })
+            
+            return results
+        except Exception as e:
+            logger.error(f"Failed to query similar mentors: {str(e)}")
+            raise
+    
+    def delete_mentor(self, mentor_id: str) -> bool:
+        try:
+            PineconeService._index.delete(ids=[str(mentor_id)])
+            logger.info(f"Mentor {mentor_id} deleted successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to delete mentor {mentor_id}: {str(e)}")
+            raise
+    
+    def delete_mentors_batch(self, mentor_ids: List[str]) -> bool:
+        try:
+            PineconeService._index.delete(ids=[str(id) for id in mentor_ids])
+            logger.info(f"Batch deleted {len(mentor_ids)} mentors")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to batch delete mentors: {str(e)}")
+            raise
+    
+    def get_index_stats(self) -> Dict[str, Any]:
+        try:
+            stats = PineconeService._index.describe_index_stats()
+            return {
+                "total_vectors": stats.total_vector_count,
+                "dimension": stats.dimension,
+                "index_fullness": stats.index_fullness if hasattr(stats, 'index_fullness') else None
+            }
+        except Exception as e:
+            logger.error(f"Failed to get index stats: {str(e)}")
+            raise
+
+
+

services/recommendation_service.py

@@ -0,0 +1,156 @@
+from typing import List, Dict, Any, Optional
+import logging
+from services.embedding_service import EmbeddingService
+from services.pinecone_service import PineconeService
+from services.reranker_service import RerankerService
+from utils.text_builder import build_mentor_text, build_mentee_query_text
+from utils.scoring import rerank_mentors
+from config.settings import get_settings
+
+logger = logging.getLogger(__name__)
+
+class RecommendationService:
+    def __init__(self):
+        self.embedding_service = EmbeddingService()
+        self.pinecone_service = PineconeService()
+        self.settings = get_settings()
+    
+    def upsert_mentor(
+        self,
+        mentor_data: Dict[str, Any]
+    ) -> bool:
+        try:
+            mentor_text = build_mentor_text(mentor_data)
+            embedding = self.embedding_service.encode(mentor_text, is_query=False)
+            
+            def safe_float(value, default=0.0):
+                if value is None:
+                    return default
+                try:
+                    return float(value)
+                except (ValueError, TypeError):
+                    return default
+            
+            def safe_int(value, default=0):
+                if value is None:
+                    return default
+                try:
+                    return int(value)
+                except (ValueError, TypeError):
+                    return default
+            
+            metadata = {
+                "mentor_id": str(mentor_data["mentor_id"]),
+                "rating": safe_float(mentor_data.get("rating"), 0.0),
+                "total_ratings": safe_int(mentor_data.get("total_ratings"), 0),
+                "session_count": safe_int(mentor_data.get("session_count"), 0),
+                "available_slots": safe_int(mentor_data.get("available_slots"), 0),
+                "has_availability": bool(mentor_data.get("has_availability", False)),
+                "career_id": safe_int(mentor_data.get("career_id")) if mentor_data.get("career_id") else None,
+                "status": str(mentor_data.get("status") or "ACTIVATED"),
+                "mentor_text": mentor_text
+            }
+            
+            if mentor_data.get("skill_ids"):
+                metadata["skill_ids"] = [str(int(id)) for id in mentor_data["skill_ids"]]
+            if mentor_data.get("domain_ids"):
+                metadata["domain_ids"] = [str(int(id)) for id in mentor_data["domain_ids"]]
+            
+            return self.pinecone_service.upsert_mentor(
+                mentor_id=str(mentor_data["mentor_id"]),
+                vector=embedding,
+                metadata=metadata
+            )
+        except Exception as e:
+            logger.error(f"Failed to upsert mentor: {str(e)}")
+            raise
+    
+    def recommend_mentors(
+        self,
+        mentee_data: Dict[str, Any],
+        top_k: Optional[int] = None,
+        final_count: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        try:
+            top_k = top_k or self.settings.RECOMMENDATION_TOP_K
+            final_count = final_count or self.settings.RECOMMENDATION_FINAL_COUNT
+            
+            query_text = build_mentee_query_text(mentee_data)
+            query_embedding = self.embedding_service.encode(query_text, is_query=True)
+            
+            filter_dict = self._build_filter(mentee_data)
+            
+            similar_mentors = self.pinecone_service.query_similar(
+                query_vector=query_embedding,
+                top_k=top_k,
+                filter=filter_dict if filter_dict else None,
+                include_metadata=True
+            )
+            
+            if not similar_mentors:
+                return []
+            
+            for mentor in similar_mentors:
+                metadata = mentor.get("metadata", {})
+                mentor["mentor_text"] = metadata.get("mentor_text", "")
+                if not mentor["mentor_text"]:
+                    logger.warning(f"Mentor {mentor.get('mentor_id', 'unknown')} missing mentor_text in metadata")
+            
+            reranker = RerankerService()
+            rerank_k = self.settings.RECOMMENDATION_RERANK_K
+            
+            try:
+                reranked_mentors = reranker.rerank(
+                    query_text=query_text,
+                    candidates=similar_mentors,
+                    top_k=rerank_k
+                )
+            except Exception as e:
+                logger.error(f"Reranker failed: {e}. Falling back to cosine similarity.", exc_info=True)
+                for mentor in similar_mentors:
+                    mentor["reranker_score"] = mentor.get("score", 0.0)
+                reranked_mentors = sorted(similar_mentors, key=lambda x: x.get("reranker_score", 0.0), reverse=True)[:rerank_k]
+            
+            reranked = rerank_mentors(
+                reranked_mentors,
+                mentee_data,
+                final_count=final_count
+            )
+            
+            return reranked
+        except Exception as e:
+            logger.error(f"Failed to recommend mentors: {str(e)}")
+            raise
+    
+    def _build_filter(self, mentee_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        filter_dict = {}
+        
+        if mentee_data.get("min_rating"):
+            filter_dict["rating"] = {"$gte": float(mentee_data["min_rating"])}
+        
+        if mentee_data.get("require_availability"):
+            filter_dict["has_availability"] = True
+        
+        if mentee_data.get("skill_ids"):
+            filter_dict["skill_ids"] = {"$in": [str(int(id)) for id in mentee_data["skill_ids"]]}
+        
+        if mentee_data.get("domain_ids"):
+            filter_dict["domain_ids"] = {"$in": [str(int(id)) for id in mentee_data["domain_ids"]]}
+        
+        if mentee_data.get("career_id"):
+            filter_dict["career_id"] = int(mentee_data["career_id"])
+        
+        if mentee_data.get("status"):
+            filter_dict["status"] = str(mentee_data["status"])
+        else:
+            filter_dict["status"] = "ACTIVATED"
+        
+        return filter_dict if filter_dict else None
+    
+    def delete_mentor(self, mentor_id: str) -> bool:
+        try:
+            return self.pinecone_service.delete_mentor(mentor_id)
+        except Exception as e:
+            logger.error(f"Failed to delete mentor: {str(e)}")
+            raise
+

services/reranker_service.py

@@ -0,0 +1,90 @@
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+import logging
+
+logger = logging.getLogger(__name__)
+
+class RerankerService:
+    _instance = None
+    _initialized = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(RerankerService, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if RerankerService._initialized:
+            return
+        
+        try:
+            self.model_name = "AITeamVN/Vietnamese_Reranker"
+            logger.info(f"Loading reranker model: {self.model_name}")
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
+            self.model.eval()
+            
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self.model.to(self.device)
+            
+            logger.info(f"Reranker model loaded successfully on device: {self.device}")
+            RerankerService._initialized = True
+        except Exception as e:
+            logger.error(f"Failed to load reranker model: {str(e)}", exc_info=True)
+            raise
+
+    def rerank(self, query_text: str, candidates: list, top_k: int = None) -> list:
+        if not candidates:
+            return []
+
+        if not query_text:
+            logger.warning("Empty query text provided to reranker")
+            return candidates
+
+        try:
+            pairs = []
+            valid_candidates = []
+            
+            for cand in candidates:
+                mentor_text = cand.get("mentor_text", "")
+                if mentor_text:
+                    pairs.append((query_text, mentor_text))
+                    valid_candidates.append(cand)
+                else:
+                    logger.warning(f"Mentor {cand.get('mentor_id', 'unknown')} missing mentor_text, skipping reranking")
+            
+            if not pairs:
+                logger.warning("No valid candidate pairs for reranking, returning original candidates")
+                return candidates
+
+            inputs = self.tokenizer(
+                pairs,
+                padding=True,
+                truncation=True,
+                max_length=512,
+                return_tensors="pt"
+            ).to(self.device)
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                scores = torch.sigmoid(outputs.logits).squeeze(-1).cpu().tolist()
+
+            if isinstance(scores, float):
+                scores = [scores]
+
+            for cand, score in zip(valid_candidates, scores):
+                cand["reranker_score"] = float(score)
+
+            sorted_candidates = sorted(valid_candidates, key=lambda x: x.get("reranker_score", 0.0), reverse=True)
+            
+            if top_k:
+                return sorted_candidates[:top_k]
+            return sorted_candidates
+        except Exception as e:
+            logger.error(f"Error during reranking: {str(e)}", exc_info=True)
+            for cand in candidates:
+                if "reranker_score" not in cand:
+                    cand["reranker_score"] = cand.get("score", 0.0)
+            return sorted(candidates, key=lambda x: x.get("reranker_score", 0.0), reverse=True)[:top_k] if top_k else candidates
+

utils/scoring.py

@@ -0,0 +1,98 @@
+from typing import List, Dict, Any
+import math
+from config.settings import get_settings
+
+def rerank_mentors(
+    similar_mentors: List[Dict[str, Any]],
+    mentee_data: Dict[str, Any],
+    final_count: int = 8
+) -> List[Dict[str, Any]]:
+    settings = get_settings()
+    scored_mentors = []
+    
+    for mentor in similar_mentors:
+        metadata = mentor.get("metadata", {})
+        
+        reranker_score = mentor.get("reranker_score")
+        if reranker_score is None:
+            reranker_score = mentor.get("score", 0.0)
+        
+        semantic_score = reranker_score * settings.SEMANTIC_WEIGHT
+        
+        rating_score = _calculate_rating_score(metadata.get("rating", 0.0))
+        availability_score = _calculate_availability_score(metadata.get("available_slots", 0))
+        
+        rule_based_score = (
+            rating_score * 0.5 +
+            availability_score * 0.5
+        ) * settings.RULE_BASED_WEIGHT
+        
+        final_score = semantic_score + rule_based_score
+        
+        original_score = mentor.get("score", 0.0)
+        
+        reason = _generate_reason(
+            reranker_score,
+            metadata,
+            mentee_data,
+            rating_score,
+            availability_score
+        )
+        
+        scored_mentors.append({
+            "mentor_id": mentor["mentor_id"],
+            "score": final_score,
+            "semantic_similarity": original_score,
+            "reranker_score": reranker_score,
+            "metadata": metadata,
+            "reason": reason
+        })
+    
+    scored_mentors.sort(key=lambda x: x["score"], reverse=True)
+    
+    return scored_mentors[:final_count]
+
+def _calculate_rating_score(rating: float) -> float:
+    if rating <= 0:
+        return 0.0
+    return min(rating / 5.0, 1.0)
+
+def _calculate_availability_score(available_slots: int) -> float:
+    if available_slots <= 0:
+        return 0.0
+    if available_slots >= 10:
+        return 1.0
+    return min(available_slots / 10.0, 1.0)
+
+
+def _generate_reason(
+    reranker_score: float,
+    metadata: Dict[str, Any],
+    mentee_data: Dict[str, Any],
+    rating_score: float,
+    availability_score: float
+) -> str:
+    reasons = []
+    
+    if reranker_score >= 0.8:
+        reasons.append("Highly relevant expertise")
+    elif reranker_score >= 0.6:
+        reasons.append("Good match for your goals")
+    
+    rating = metadata.get("rating", 0.0)
+    if rating >= 4.5:
+        reasons.append("Excellent ratings")
+    elif rating >= 4.0:
+        reasons.append("High ratings")
+    
+    available_slots = metadata.get("available_slots", 0)
+    if available_slots > 0:
+        reasons.append("Has available slots")
+    
+    if not reasons:
+        reasons.append("Good overall match")
+    
+    return "; ".join(reasons[:3])
+
+
+

utils/text_builder.py

@@ -0,0 +1,206 @@
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+def build_mentor_text(mentor_data: Dict[str, Any]) -> str:
+    parts = []
+    
+    full_name = mentor_data.get("full_name", "")
+    if full_name:
+        parts.append(f"Mentor Profile: {full_name}")
+    
+    bio = mentor_data.get("bio", "")
+    if bio:
+        parts.append(f"Bio: {bio}")
+    
+    career = mentor_data.get("career", {})
+    if isinstance(career, dict) and career.get("name"):
+        parts.append(f"Career: {career['name']}")
+    elif isinstance(career, str):
+        parts.append(f"Career: {career}")
+    
+    skills = mentor_data.get("skills", [])
+    if skills:
+        skill_names = []
+        for skill in skills:
+            if isinstance(skill, dict):
+                skill_names.append(skill.get("name", ""))
+            elif isinstance(skill, str):
+                skill_names.append(skill)
+        if skill_names:
+            parts.append(f"Skills: {', '.join(skill_names)}")
+    
+    domains = mentor_data.get("domains", [])
+    if domains:
+        domain_names = []
+        for domain in domains:
+            if isinstance(domain, dict):
+                domain_names.append(domain.get("name", ""))
+            elif isinstance(domain, str):
+                domain_names.append(domain)
+        if domain_names:
+            parts.append(f"Domains: {', '.join(domain_names)}")
+    
+    experiences = mentor_data.get("experiences", [])
+    if experiences:
+        exp_parts = []
+        for exp in experiences:
+            if isinstance(exp, dict):
+                position = exp.get("position", "")
+                company = exp.get("company", "")
+                start_date = exp.get("start_date", "")
+                end_date = exp.get("end_date", "") or "Present"
+                description = exp.get("description", "")
+                
+                exp_str = f"  - {position}"
+                if company:
+                    exp_str += f" at {company}"
+                if start_date:
+                    exp_str += f" ({start_date} - {end_date})"
+                if description:
+                    exp_str += f": {description}"
+                exp_parts.append(exp_str)
+        
+        if exp_parts:
+            parts.append("Experience Details:")
+            parts.extend(exp_parts)
+    
+    educations = mentor_data.get("educations", [])
+    if educations:
+        edu_parts = []
+        for edu in educations:
+            if isinstance(edu, dict):
+                degree = edu.get("degree", "")
+                school = edu.get("school", "")
+                start_date = edu.get("start_date", "")
+                end_date = edu.get("end_date", "")
+                description = edu.get("description", "")
+                
+                edu_str = "  -"
+                if degree:
+                    edu_str += f" {degree}"
+                if school:
+                    edu_str += f" from {school}"
+                if start_date:
+                    edu_str += f" ({start_date} - {end_date})"
+                if description:
+                    edu_str += f": {description}"
+                edu_parts.append(edu_str)
+        
+        if edu_parts:
+            parts.append("Education:")
+            parts.extend(edu_parts)
+    
+    rating = mentor_data.get("rating", 0.0)
+    total_ratings = mentor_data.get("total_ratings", 0)
+    if rating or total_ratings:
+        parts.append(f"Rating: {rating:.1f}/5.0 ({total_ratings} reviews)")
+    
+    session_count = mentor_data.get("session_count", 0)
+    if session_count:
+        parts.append(f"Sessions Conducted: {session_count}")
+    
+    available_slots = mentor_data.get("available_slots", 0)
+    if available_slots:
+        parts.append(f"Available Slots: {available_slots}")
+    
+    schedules = mentor_data.get("schedules", [])
+    if schedules:
+        schedule_summary = _build_schedule_summary(schedules)
+        if schedule_summary:
+            parts.append(f"Availability: {schedule_summary}")
+    
+    return "\n".join(parts)
+
+def build_mentee_query_text(mentee_data: Dict[str, Any]) -> str:
+    parts = ["Looking for mentor to help with:"]
+    
+    goals = mentee_data.get("goals", "")
+    if goals:
+        parts.append(f"Goals: {goals}")
+    
+    desired_skills = mentee_data.get("desired_skills", [])
+    if desired_skills:
+        skill_names = []
+        for skill in desired_skills:
+            if isinstance(skill, dict):
+                skill_names.append(skill.get("name", ""))
+            elif isinstance(skill, str):
+                skill_names.append(skill)
+        if skill_names:
+            parts.append(f"Desired Skills: {', '.join(skill_names)}")
+    
+    current_skills = mentee_data.get("current_skills", [])
+    if current_skills:
+        skill_names = []
+        for skill in current_skills:
+            if isinstance(skill, dict):
+                skill_names.append(skill.get("name", ""))
+            elif isinstance(skill, str):
+                skill_names.append(skill)
+        if skill_names:
+            parts.append(f"Current Skills: {', '.join(skill_names)}")
+    
+    interests = mentee_data.get("interests", [])
+    domains = mentee_data.get("domains", [])
+    if interests:
+        domain_names = []
+        for domain in interests:
+            if isinstance(domain, dict):
+                domain_names.append(domain.get("name", ""))
+            elif isinstance(domain, str):
+                domain_names.append(domain)
+        if domain_names:
+            parts.append(f"Interests: {', '.join(domain_names)}")
+    elif domains:
+        domain_names = []
+        for domain in domains:
+            if isinstance(domain, dict):
+                domain_names.append(domain.get("name", ""))
+            elif isinstance(domain, str):
+                domain_names.append(domain)
+        if domain_names:
+            parts.append(f"Interests: {', '.join(domain_names)}")
+    
+    availability = mentee_data.get("availability", "")
+    preferred_availability = mentee_data.get("preferred_availability", "")
+    if availability or preferred_availability:
+        parts.append(f"Preferred Availability: {availability or preferred_availability}")
+    
+    return "\n".join(parts)
+
+def _build_schedule_summary(schedules: List[Dict[str, Any]]) -> str:
+    if not schedules:
+        return ""
+    
+    day_names = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+    active_schedules = [s for s in schedules if s.get("is_active", 1) == 1]
+    
+    if not active_schedules:
+        return ""
+    
+    schedule_groups = {}
+    for schedule in active_schedules:
+        day = schedule.get("day_of_week", 0)
+        start = schedule.get("start_time", "")
+        end = schedule.get("end_time", "")
+        
+        if day < 7:
+            day_name = day_names[day]
+            time_str = f"{start}-{end}" if start and end else ""
+            if day_name not in schedule_groups:
+                schedule_groups[day_name] = []
+            if time_str:
+                schedule_groups[day_name].append(time_str)
+    
+    if not schedule_groups:
+        return ""
+    
+    summary_parts = []
+    for day, times in sorted(schedule_groups.items()):
+        if times:
+            summary_parts.append(f"{day} {', '.join(times)}")
+    
+    return "; ".join(summary_parts)
+
+
+