""" Módulo de Integración de Asistente IA (Chatbot de Ayuda Contextual) SDD-009: Compatible con OpenAI API y Servidor Local Llama.cpp (Qwen3 Coder 30B) """ import time from typing import Optional import httpx from fastapi import APIRouter, HTTPException, Depends, Request, status from dependencies import get_optional_current_user, require_roles from app.models.setting import SystemSetting from app.models.user import User from schemas.ai_chat import ( ChatRequest, ChatResponse, AITestConnectionResponse, AISettingsSchema ) router = APIRouter(tags=["AI Chatbot"]) def generate_system_prompt_for_role(role: Optional[str]) -> str: """ Genera el System Prompt dinámico según el rol del usuario autenticado, proporcionándole al LLM las reglas de negocio, manual de uso y restricciones de acceso. """ normalized_role = (role or "alumno").strip().lower() if normalized_role in ["docente", "profesor", "teacher"]: return ( "Eres el Asistente y Tutor Inteligente de Admin Edu Space (UniCABA) para DOCENTES y PROFESORES.\n" "Tu objetivo es asistir al cuerpo docente guiándolo exclusivamente en las tareas pertinentes a su rol:\n" "1. Asignaciones de Aula y Espacios: Explicar cómo consultar las aulas físicas asignadas y enlaces a aulas virtuales (Google Meet/Teams) en la cartelera diaria y semanal.\n" "2. Libro de Calificaciones (Gradebook): Orientar sobre cómo cargar y editar calificaciones de parciales, recuperatorios, notas finales y cerrar actas de regularidad inmutables con trazabilidad.\n" "3. Nómina de Comisiones y Alumnos: Guiar en la visualización de listas de alumnos inscriptos en sus comisiones activas.\n" "4. Cronogramas y Horarios: Indicar cómo consultar días y horarios de cursada según el ciclo lectivo vigente.\n" "REGLAS ESTRICTAS DE SEGURIDAD Y PERMISOS:\n" "- Si el usuario te consulta sobre cómo crear carreras, modificar asignaciones físicas ajenas, reconfigurar servidores o ingresar a funciones de Bedelía, aclara respetuosamente que esas operaciones están reservadas a Bedelía o Administración de Sistemas.\n" "- Responde siempre en español institucional, con tono cordial, empático y estructurado en pasos claros." ) elif normalized_role in ["bedelia", "admin", "administrador"]: return ( "Eres el Asistente y Tutor Técnico de Nivel 1 de Admin Edu Space (UniCABA) para personal de BEDELÍA y ADMINISTRADORES.\n" "Tu objetivo es brindar soporte técnico operativo y guiar en el flujo integral de gestión académica y áulica:\n" "1. Circuito Secuencial Canónico de 9 Pasos: 1) Sedes/Edificios -> 2) Aulas (físicas/virtuales) -> 3) Ciclos Lectivos -> 4) Carreras -> 5) Asignaturas (con carreras asociadas) -> 6) Comisiones -> 7) Profesores -> 8) Alumnos -> 9) Reservas de Espacio.\n" "2. Matriz de Conflictos: Explicar la validación física en aulas presenciales, control estricto de aforo, superposición horaria docente (con excepción de co-docencia activa) y restricción diaria de cursada para alumnos.\n" "3. Herramienta de Optimización con IA: Instruir sobre el uso del Optimizador Genético de Aulas para resolver colisiones y maximizar aforo.\n" "4. Importación Masiva (Google Sheets): Explicar el proceso de inspección previa, selección granular de entidades, filtrado por carrera/día y carga con fechas manuales.\n" "5. Sincronización Moodle 4.1: Orientar en la gestión de la cola asíncrona (MoodleSyncTask), manejo de reintentos, Dead Letter Queue (DLQ) y sincronización RBAC.\n" "6. Auditoría Institucional: Indicar cómo auditar eventos en AuditLog por módulo, acción y fecha.\n" "REGLAS:\n" "- Responde con precisión técnica, terminología oficial de UniCABA y soluciones directas y accionables." ) else: # Rol Alumno / Estudiante (por defecto) return ( "Eres el Asistente y Tutor Inteligente de Admin Edu Space (UniCABA) para ESTUDIANTES y ALUMNOS.\n" "Tu misión es guiar al estudiante sobre cómo cursar y utilizar el sistema:\n" "1. Cartelera de Clases de Hoy: Enseñar cómo consultar en qué aula física o enlace virtual de Meet le corresponde cursar sus materias hoy y en qué turno.\n" "2. Mis Asignaturas e Inscripciones: Explicar cómo verificar las materias matriculadas, comisiones, docentes a cargo y horarios de cursada.\n" "3. Consulta de Calificaciones: Guiar en la visualización de estados académicos, notas parciales, recuperatorios y regularidad en el sistema.\n" "4. Restricción de Cursada Diaria: Explicar que el sistema restringe cursar dos materias el mismo día salvo cursos cortos o excepciones autorizadas por Bedelía.\n" "REGLAS ESTRICTAS DE SEGURIDAD:\n" "- Tienes TERMINANTEMENTE PROHIBIDO enseñar o detallar cómo reservar aulas, cómo alterar notas, cómo sincronizar Moodle o cómo administrar el sistema.\n" "- Ante cualquier solicitud de índole administrativa o de reclamo de cupos, indica al alumno que debe dirigirse a la Secretaría de Bedelía de UniCABA.\n" "- Responde en español de forma pedagógica, clara y amigable." ) def _get_ai_config() -> dict: """Recupera la configuración activa del motor de IA desde SystemSetting.""" enabled_val = SystemSetting.get_value("ai_chat_enabled", "true") enabled = enabled_val in ["true", "True", "1", True] base_url = SystemSetting.get_value("ai_chat_base_url", "http://10.0.0.214:8080/v1") or "http://10.0.0.214:8080/v1" # Obtener clave API descifrada api_key = SystemSetting.get_decrypted_value("ai_chat_api_key", "llama") or "llama" model = SystemSetting.get_value("ai_chat_model", "qwen3-coder:30b") or "qwen3-coder:30b" model_name = SystemSetting.get_value("ai_chat_model_name", "Qwen3 Coder 30B-A3B (Llama.cpp)") or "Qwen3 Coder 30B-A3B (Llama.cpp)" try: temperature = float(SystemSetting.get_value("ai_chat_temperature", 0.3)) except (ValueError, TypeError): temperature = 0.3 try: timeout = float(SystemSetting.get_value("ai_chat_timeout", 60.0)) except (ValueError, TypeError): timeout = 60.0 return { "enabled": enabled, "base_url": base_url.strip().rstrip("/"), "api_key": api_key.strip(), "model": model.strip(), "model_name": model_name.strip(), "temperature": temperature, "timeout": timeout } @router.post("/", response_model=ChatResponse) @router.post("", response_model=ChatResponse) async def get_agent_response( request: ChatRequest, req: Request, current_user: Optional[User] = Depends(get_optional_current_user) ): """ Procesa la conversación del usuario con el agente contextual: 1. Resuelve el rol del usuario (prioriza sesión JWT o campo user_role). 2. Inyecta el System Prompt correspondiente al rol. 3. Envía la solicitud asíncrona no bloqueante hacia el servidor local Llama.cpp. """ config = _get_ai_config() if not config["enabled"]: raise HTTPException( status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="El servicio de Asistente IA está temporalmente deshabilitado por el administrador." ) # 1. Determinar rol efectivo effective_role = request.user_role or "alumno" if current_user: if getattr(current_user, "is_admin", False) or (getattr(current_user, "role", "") or "").upper() == "ADMIN": effective_role = "bedelia" elif hasattr(current_user, "role") and current_user.role: role_str = str(current_user.role).lower() if "docente" in role_str or "profesor" in role_str or "teacher" in role_str: effective_role = "docente" elif "bedelia" in role_str or "admin" in role_str: effective_role = "bedelia" else: effective_role = "alumno" # 2. Inyección de Contexto system_prompt = generate_system_prompt_for_role(effective_role) formatted_messages = [{"role": "system", "content": system_prompt}] for msg in request.messages: formatted_messages.append({"role": msg.role, "content": msg.content}) payload = { "model": config["model"], "messages": formatted_messages, "temperature": config["temperature"] } target_url = f"{config['base_url']}/chat/completions" headers = { "Authorization": f"Bearer {config['api_key']}", "Content-Type": "application/json" } # 3. Petición asíncrona no bloqueante al servidor local async with httpx.AsyncClient(timeout=config["timeout"]) as client: try: response = await client.post(target_url, headers=headers, json=payload) response.raise_for_status() ai_data = response.json() reply_text = ai_data["choices"][0]["message"]["content"] return ChatResponse(response=reply_text) except httpx.TimeoutException: raise HTTPException( status_code=status.HTTP_504_GATEWAY_TIMEOUT, detail=f"El servidor de IA local superó el tiempo límite de espera ({config['timeout']}s)." ) except httpx.HTTPStatusError as e: detail_msg = f"Error del motor de IA local ({e.response.status_code}): {e.response.text[:200]}" raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=detail_msg) except httpx.RequestError as e: raise HTTPException( status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Error conectando al motor de IA local. Verifique que Llama.cpp esté activo en 10.0.0.214." ) @router.post("/test-connection", response_model=AITestConnectionResponse) async def test_ai_connection( current_user: User = Depends(require_roles(["ADMIN"])) ): """ Verifica la conectividad directa con el servidor local Llama.cpp consultando el endpoint de modelos /v1/models y calculando la latencia. """ config = _get_ai_config() target_url = f"{config['base_url']}/models" headers = {"Authorization": f"Bearer {config['api_key']}"} start_time = time.time() async with httpx.AsyncClient(timeout=10.0) as client: try: resp = await client.get(target_url, headers=headers) latency_ms = round((time.time() - start_time) * 1000, 2) if resp.status_code == 200: data = resp.json() model_ids = [m.get("id") for m in data.get("data", []) if isinstance(m, dict) and "id" in m] return AITestConnectionResponse( status="success", message=f"Conexión exitosa con Llama.cpp ({config['base_url']}). Latencia: {latency_ms} ms.", latency_ms=latency_ms, models=model_ids ) else: return AITestConnectionResponse( status="warning", message=f"Respuesta inesperada del servidor ({resp.status_code}): {resp.text[:200]}", latency_ms=latency_ms, models=[] ) except httpx.TimeoutException: return AITestConnectionResponse( status="error", message=f"Tiempo de espera agotado al conectar a {config['base_url']} (Timeout: 10s).", latency_ms=None, models=[] ) except httpx.RequestError as e: return AITestConnectionResponse( status="error", message=f"No se pudo conectar a {config['base_url']}: {str(e)}", latency_ms=None, models=[] ) @router.get("/config") def get_ai_public_config(current_user: Optional[User] = Depends(get_optional_current_user)): """Retorna metadatos públicos de estado del asistente para el widget del frontend.""" config = _get_ai_config() return { "status": "success", "enabled": config["enabled"], "model": config["model"], "model_name": config["model_name"] }