feat: integración de Asistente IA contextual con Llama.cpp Qwen3 Coder 30B (SDD-009, v3.8.24)
This commit is contained in:
@@ -7,7 +7,7 @@ from typing import Any
|
||||
from database import db, get_db, engine, SessionLocal, session
|
||||
from config.config import Config
|
||||
|
||||
__version__ = "3.8.23"
|
||||
__version__ = "3.8.24"
|
||||
|
||||
class DummyContext:
|
||||
def __enter__(self):
|
||||
|
||||
@@ -19,6 +19,7 @@ from routers.admin import admin_router
|
||||
from routers.students import students_router
|
||||
from routers.dashboard import dashboard_router
|
||||
from routers.optimizer import optimizer_router, genetic_router
|
||||
from routers.ai_chat import router as ai_chat_router
|
||||
|
||||
# Initialize FastAPI Application
|
||||
app = FastAPI(
|
||||
@@ -51,6 +52,8 @@ app.include_router(students_router)
|
||||
app.include_router(dashboard_router)
|
||||
app.include_router(optimizer_router)
|
||||
app.include_router(genetic_router)
|
||||
app.include_router(ai_chat_router, prefix="/api/chat")
|
||||
app.include_router(ai_chat_router, prefix="/api/v1/chat")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
+123
-1
@@ -852,6 +852,18 @@ def get_all_settings(current_user: User = Depends(require_roles(["ADMIN"]))):
|
||||
'show_role_banner': SystemSetting.get_value('dashboard_role_banner_enabled', 'true') in ['true', 'True', '1', True]
|
||||
}
|
||||
|
||||
ai_config = {
|
||||
'enabled': SystemSetting.get_value('ai_chat_enabled', 'true') in ['true', 'True', '1', True],
|
||||
'base_url': SystemSetting.get_value('ai_chat_base_url', 'http://10.0.0.214:8080/v1'),
|
||||
'api_key': SystemSetting.get_masked_value('ai_chat_api_key', '••••••••••••') if SystemSetting.get_value('ai_chat_api_key') else 'llama',
|
||||
'model': SystemSetting.get_value('ai_chat_model', 'qwen3-coder:30b'),
|
||||
'model_name': SystemSetting.get_value('ai_chat_model_name', 'Qwen3 Coder 30B-A3B (Llama.cpp)'),
|
||||
'temperature': float(SystemSetting.get_value('ai_chat_temperature', 0.3) or 0.3),
|
||||
'timeout': int(SystemSetting.get_value('ai_chat_timeout', 60) or 60),
|
||||
'context_limit': int(SystemSetting.get_value('ai_chat_context_limit', 65536) or 65536),
|
||||
'output_limit': int(SystemSetting.get_value('ai_chat_output_limit', 65536) or 65536)
|
||||
}
|
||||
|
||||
return {
|
||||
'status': 'success',
|
||||
'settings': {
|
||||
@@ -859,7 +871,9 @@ def get_all_settings(current_user: User = Depends(require_roles(["ADMIN"]))):
|
||||
'auth_providers': auth_providers,
|
||||
'google_oauth': google_oauth,
|
||||
'moodle': moodle_config,
|
||||
'ui': ui_config
|
||||
'ui': ui_config,
|
||||
'ai': ai_config,
|
||||
'ai_assistant': ai_config
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1052,6 +1066,114 @@ async def update_ui_settings(
|
||||
}
|
||||
|
||||
|
||||
@admin_router.post("/settings/ai")
|
||||
@admin_router.post("/admin/settings/ai")
|
||||
async def update_ai_settings(
|
||||
request: Request,
|
||||
current_user: User = Depends(require_roles(["ADMIN"]))
|
||||
):
|
||||
"""Actualiza la configuración del proveedor de IA local (Llama.cpp / Qwen3)."""
|
||||
data = await get_request_payload(request)
|
||||
|
||||
enabled_input = data.get('enabled')
|
||||
enabled = 'true' if enabled_input in [True, 'true', '1', 'on', 1] else 'false'
|
||||
base_url = str(data.get('base_url', 'http://10.0.0.214:8080/v1')).strip().rstrip('/')
|
||||
api_key = str(data.get('api_key', '')).strip()
|
||||
model = str(data.get('model', 'qwen3-coder:30b')).strip()
|
||||
model_name = str(data.get('model_name', 'Qwen3 Coder 30B-A3B (Llama.cpp)')).strip()
|
||||
temperature = str(data.get('temperature', '0.3')).strip()
|
||||
timeout = str(data.get('timeout', '60')).strip()
|
||||
context_limit = str(data.get('context_limit', '65536')).strip()
|
||||
output_limit = str(data.get('output_limit', '65536')).strip()
|
||||
|
||||
SystemSetting.set_value('ai_chat_enabled', enabled, 'Habilitación de Asistente IA', category='ai')
|
||||
SystemSetting.set_value('ai_chat_base_url', base_url, 'URL base del servidor Llama.cpp', category='ai')
|
||||
if api_key and api_key != '••••••••••••':
|
||||
SystemSetting.set_encrypted_value('ai_chat_api_key', api_key, 'Clave API del servidor de IA', category='ai')
|
||||
SystemSetting.set_value('ai_chat_model', model, 'ID del modelo Llama.cpp', category='ai')
|
||||
SystemSetting.set_value('ai_chat_model_name', model_name, 'Nombre descriptivo del modelo', category='ai')
|
||||
SystemSetting.set_value('ai_chat_temperature', temperature, 'Temperatura de generación', category='ai')
|
||||
SystemSetting.set_value('ai_chat_timeout', timeout, 'Timeout de inferencia en segundos', category='ai')
|
||||
SystemSetting.set_value('ai_chat_context_limit', context_limit, 'Límite de tokens de contexto', category='ai')
|
||||
SystemSetting.set_value('ai_chat_output_limit', output_limit, 'Límite de tokens de respuesta', category='ai')
|
||||
|
||||
AuditService.log(
|
||||
action='UPDATE_AI_SETTINGS',
|
||||
module='settings',
|
||||
user=current_user,
|
||||
details=f"Configuración de Asistente IA actualizada (Modelo: {model}, URL: {base_url})"
|
||||
)
|
||||
|
||||
return {
|
||||
'status': 'success',
|
||||
'message': 'Configuración de Asistente IA guardada exitosamente.',
|
||||
'settings': {
|
||||
'enabled': enabled == 'true',
|
||||
'base_url': base_url,
|
||||
'model': model,
|
||||
'model_name': model_name,
|
||||
'temperature': float(temperature) if temperature else 0.3,
|
||||
'timeout': int(timeout) if timeout else 60
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@admin_router.post("/settings/ai/test")
|
||||
@admin_router.post("/admin/settings/ai/test")
|
||||
async def test_ai_settings_connection(
|
||||
request: Request,
|
||||
current_user: User = Depends(require_roles(["ADMIN"]))
|
||||
):
|
||||
"""Prueba en tiempo real la conectividad con el servidor de IA local."""
|
||||
import time
|
||||
import httpx
|
||||
|
||||
data = await get_request_payload(request)
|
||||
base_url = str(data.get('base_url') or SystemSetting.get_value('ai_chat_base_url', 'http://10.0.0.214:8080/v1')).strip().rstrip('/')
|
||||
api_key = data.get('api_key')
|
||||
if not api_key or api_key == '••••••••••••':
|
||||
api_key = SystemSetting.get_decrypted_value('ai_chat_api_key', 'llama') or 'llama'
|
||||
|
||||
target_url = f"{base_url}/models"
|
||||
headers = {"Authorization": f"Bearer {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_json = resp.json()
|
||||
models = [m.get("id") for m in data_json.get("data", []) if isinstance(m, dict) and "id" in m]
|
||||
return {
|
||||
'status': 'success',
|
||||
'message': f"Conexión exitosa con Llama.cpp ({base_url}). Latencia: {latency_ms} ms.",
|
||||
'latency_ms': latency_ms,
|
||||
'models': models
|
||||
}
|
||||
else:
|
||||
return {
|
||||
'status': 'warning',
|
||||
'message': f"Respuesta inesperada del servidor ({resp.status_code}): {resp.text[:200]}",
|
||||
'latency_ms': latency_ms,
|
||||
'models': []
|
||||
}
|
||||
except httpx.TimeoutException:
|
||||
return {
|
||||
'status': 'error',
|
||||
'message': f"Tiempo de espera agotado al conectar a {base_url} (Timeout: 10s).",
|
||||
'latency_ms': None,
|
||||
'models': []
|
||||
}
|
||||
except httpx.RequestError as e:
|
||||
return {
|
||||
'status': 'error',
|
||||
'message': f"No se pudo conectar a {base_url}: {str(e)}",
|
||||
'latency_ms': None,
|
||||
'models': []
|
||||
}
|
||||
|
||||
|
||||
@admin_router.get("/settings/demo-mode")
|
||||
@admin_router.get("/admin/settings/demo-mode")
|
||||
def get_demo_mode_status(current_user: User = Depends(require_roles(["ADMIN"]))):
|
||||
|
||||
@@ -0,0 +1,241 @@
|
||||
"""
|
||||
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"]
|
||||
}
|
||||
@@ -1 +1,3 @@
|
||||
# Schemas package initialization
|
||||
from schemas.auth import *
|
||||
from schemas.ai_chat import *
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
from typing import Optional, List
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
|
||||
class ChatMessage(BaseModel):
|
||||
role: str = Field(..., pattern="^(user|assistant|system)$", description="Rol del emisor: user, assistant o system")
|
||||
content: str = Field(..., min_length=1, description="Contenido textual del mensaje")
|
||||
|
||||
|
||||
class ChatRequest(BaseModel):
|
||||
messages: List[ChatMessage] = Field(..., min_length=1, description="Historial de mensajes de la conversación")
|
||||
user_role: Optional[str] = Field("alumno", description="Rol del usuario: alumno, docente, bedelia, admin")
|
||||
|
||||
|
||||
class ChatResponse(BaseModel):
|
||||
response: str = Field(..., description="Respuesta generada por el agente conversacional")
|
||||
|
||||
|
||||
class AISettingsSchema(BaseModel):
|
||||
enabled: bool = Field(True, description="Habilitación del servicio de Asistente IA")
|
||||
base_url: str = Field("http://10.0.0.214:8080/v1", description="URL base de la API compatible OpenAI / Llama.cpp")
|
||||
api_key: str = Field("llama", description="Clave API para autenticación con el servidor local")
|
||||
model: str = Field("qwen3-coder:30b", description="Identificador del modelo en Llama.cpp")
|
||||
model_name: Optional[str] = Field("Qwen3 Coder 30B-A3B (Llama.cpp)", description="Nombre amigable del modelo")
|
||||
temperature: float = Field(0.3, ge=0.0, le=2.0, description="Temperatura para control de variabilidad (0.0 a 2.0)")
|
||||
timeout: int = Field(60, ge=5, le=600, description="Tiempo límite de espera en segundos")
|
||||
context_limit: int = Field(65536, ge=512, description="Ventana de contexto máxima en tokens")
|
||||
output_limit: int = Field(65536, ge=128, description="Límite máximo de salida de tokens")
|
||||
|
||||
|
||||
class AITestConnectionResponse(BaseModel):
|
||||
status: str
|
||||
message: str
|
||||
latency_ms: Optional[float] = None
|
||||
models: Optional[List[str]] = None
|
||||
+1
-1
@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
|
||||
|
||||
setup(
|
||||
name="edu-space-admin",
|
||||
version="3.8.23",
|
||||
version="3.8.24",
|
||||
description="Administrative interface for Edu-Space Classroom Management System (FastAPI ASGI Core)",
|
||||
author="Edu-Space Development Team",
|
||||
author_email="admin@edu-space.com",
|
||||
|
||||
@@ -0,0 +1,257 @@
|
||||
"""
|
||||
Suite de pruebas automatizadas para el módulo de Asistente IA (SDD-009).
|
||||
Valida contratos Pydantic v2, inyección de System Prompts por rol,
|
||||
llamadas asíncronas con httpx (mockeadas) y gestión de configuración administrativa.
|
||||
"""
|
||||
from unittest.mock import AsyncMock, patch, MagicMock
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
from fastapi.testclient import TestClient
|
||||
import httpx
|
||||
from werkzeug.security import generate_password_hash
|
||||
|
||||
from main import app
|
||||
from schemas.ai_chat import ChatMessage, ChatRequest, ChatResponse, AISettingsSchema
|
||||
from routers.ai_chat import generate_system_prompt_for_role
|
||||
from app.models.setting import SystemSetting
|
||||
from app.models.user import User
|
||||
|
||||
|
||||
def test_ai_chat_pydantic_schemas_validation():
|
||||
"""Valida restricciones de datos y tipos en Pydantic v2."""
|
||||
# 1. ChatMessage válido
|
||||
msg = ChatMessage(role="user", content="¿Dónde curso hoy?")
|
||||
assert msg.role == "user"
|
||||
assert msg.content == "¿Dónde curso hoy?"
|
||||
|
||||
# 2. Rechazo por rol inválido
|
||||
with pytest.raises(ValidationError):
|
||||
ChatMessage(role="hacker", content="Mensaje")
|
||||
|
||||
# 3. Rechazo por contenido vacío
|
||||
with pytest.raises(ValidationError):
|
||||
ChatMessage(role="user", content="")
|
||||
|
||||
# 4. ChatRequest válido
|
||||
req = ChatRequest(messages=[msg], user_role="docente")
|
||||
assert len(req.messages) == 1
|
||||
assert req.user_role == "docente"
|
||||
|
||||
# 5. ChatRequest rechaza lista vacía de mensajes
|
||||
with pytest.raises(ValidationError):
|
||||
ChatRequest(messages=[], user_role="alumno")
|
||||
|
||||
# 6. AISettingsSchema con validaciones de rango
|
||||
ai_settings = AISettingsSchema(temperature=0.7, timeout=120)
|
||||
assert ai_settings.temperature == 0.7
|
||||
assert ai_settings.timeout == 120
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
AISettingsSchema(temperature=3.5) # Mayor a 2.0
|
||||
|
||||
|
||||
def test_system_prompt_generation_by_role():
|
||||
"""Verifica que el System Prompt inyectado se adapte rigurosamente al rol."""
|
||||
# Docente
|
||||
prompt_docente = generate_system_prompt_for_role("docente")
|
||||
assert "DOCENTES y PROFESORES" in prompt_docente
|
||||
assert "Gradebook" in prompt_docente
|
||||
assert "Google Meet" in prompt_docente
|
||||
assert "Bedelía" in prompt_docente # Restricción de permisos
|
||||
|
||||
# Alumno
|
||||
prompt_alumno = generate_system_prompt_for_role("alumno")
|
||||
assert "ESTUDIANTES y ALUMNOS" in prompt_alumno
|
||||
assert "Cartelera de Clases de Hoy" in prompt_alumno
|
||||
assert "TERMINANTEMENTE PROHIBIDO" in prompt_alumno
|
||||
|
||||
# Bedelía / Admin
|
||||
prompt_bedelia = generate_system_prompt_for_role("bedelia")
|
||||
assert "BEDELÍA y ADMINISTRADORES" in prompt_bedelia
|
||||
assert "Circuito Secuencial Canónico de 9 Pasos" in prompt_bedelia
|
||||
assert "Matriz de Conflictos" in prompt_bedelia
|
||||
assert "Moodle 4.1" in prompt_bedelia
|
||||
|
||||
|
||||
def test_ai_chat_public_config_endpoint():
|
||||
"""Verifica el endpoint público /api/chat/config utilizado por el widget."""
|
||||
client = TestClient(app)
|
||||
response = client.get("/api/chat/config")
|
||||
assert response.status_code == 200
|
||||
data = response.json()
|
||||
assert data["status"] == "success"
|
||||
assert "enabled" in data
|
||||
assert "model" in data
|
||||
|
||||
|
||||
def test_ai_chat_endpoint_success_mock(init_database):
|
||||
"""Simula una respuesta exitosa 200 de Llama.cpp."""
|
||||
client = TestClient(app)
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
"choices": [
|
||||
{
|
||||
"message": {
|
||||
"role": "assistant",
|
||||
"content": "Para consultar el aula de cursada hoy, accede a la Cartelera de Clases en tu panel principal."
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.return_value = mock_response
|
||||
|
||||
# Prueba en /api/chat
|
||||
res = client.post("/api/chat", json={
|
||||
"messages": [{"role": "user", "content": "¿En qué aula curso hoy?"}],
|
||||
"user_role": "alumno"
|
||||
})
|
||||
assert res.status_code == 200
|
||||
data = res.json()
|
||||
assert "response" in data
|
||||
assert "Cartelera" in data["response"]
|
||||
|
||||
# Prueba en /api/v1/chat
|
||||
res_v1 = client.post("/api/v1/chat", json={
|
||||
"messages": [{"role": "user", "content": "¿Cómo reservo un aula?"}],
|
||||
"user_role": "docente"
|
||||
})
|
||||
assert res_v1.status_code == 200
|
||||
|
||||
|
||||
def test_ai_chat_endpoint_validation_error():
|
||||
"""Valida que una petición malformada responda 422 Unprocessable Entity."""
|
||||
client = TestClient(app)
|
||||
|
||||
# Mensajes vacíos
|
||||
res = client.post("/api/chat", json={
|
||||
"messages": [],
|
||||
"user_role": "alumno"
|
||||
})
|
||||
assert res.status_code == 422
|
||||
|
||||
# Mensaje sin contenido
|
||||
res2 = client.post("/api/chat", json={
|
||||
"messages": [{"role": "user", "content": ""}]
|
||||
})
|
||||
assert res2.status_code == 422
|
||||
|
||||
|
||||
def test_ai_chat_endpoint_connection_failure():
|
||||
"""Simula error de conexión con el servidor Llama.cpp y verifica HTTP 503."""
|
||||
client = TestClient(app)
|
||||
|
||||
with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.side_effect = httpx.ConnectError("Connection refused")
|
||||
|
||||
res = client.post("/api/chat", json={
|
||||
"messages": [{"role": "user", "content": "Hola tutor"}]
|
||||
})
|
||||
assert res.status_code == 503
|
||||
data = res.json()
|
||||
assert "detail" in data
|
||||
assert "10.0.0.214" in data["detail"] or "motor de IA" in data["detail"]
|
||||
|
||||
|
||||
def test_ai_chat_endpoint_timeout_failure():
|
||||
"""Simula tiempo de espera agotado y verifica HTTP 504."""
|
||||
client = TestClient(app)
|
||||
|
||||
with patch("httpx.AsyncClient.post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.side_effect = httpx.TimeoutException("Read timed out")
|
||||
|
||||
res = client.post("/api/chat", json={
|
||||
"messages": [{"role": "user", "content": "Pregunta compleja"}]
|
||||
})
|
||||
assert res.status_code == 504
|
||||
data = res.json()
|
||||
assert "tiempo límite" in data["detail"]
|
||||
|
||||
|
||||
def test_ai_chat_disabled_flow(init_database):
|
||||
"""Verifica que si ai_chat_enabled es false, se retorne 503 inmediatamente."""
|
||||
client = TestClient(app)
|
||||
|
||||
SystemSetting.set_value("ai_chat_enabled", "false", category="ai")
|
||||
try:
|
||||
res = client.post("/api/chat", json={
|
||||
"messages": [{"role": "user", "content": "Test"}]
|
||||
})
|
||||
assert res.status_code == 503
|
||||
assert "deshabilitado" in res.json()["detail"].lower()
|
||||
finally:
|
||||
SystemSetting.set_value("ai_chat_enabled", "true", category="ai")
|
||||
|
||||
|
||||
def test_admin_settings_ai_crud_and_test_connection(init_database):
|
||||
"""Verifica los endpoints administrativos de guardado y prueba de conexión de IA."""
|
||||
client = TestClient(app)
|
||||
|
||||
# 1. Crear usuario Admin
|
||||
u = User(
|
||||
email="admin.ai@unicaba.edu.ar",
|
||||
name="Admin AI Settings",
|
||||
password_hash=generate_password_hash("AiAdminSecret!"),
|
||||
role="ADMIN",
|
||||
is_active=True
|
||||
)
|
||||
init_database.session.add(u)
|
||||
init_database.session.commit()
|
||||
|
||||
# Login
|
||||
login_res = client.post("/api/v1/auth/login", json={
|
||||
"email": "admin.ai@unicaba.edu.ar",
|
||||
"password": "AiAdminSecret!"
|
||||
})
|
||||
token = login_res.json()["access_token"]
|
||||
headers = {"Authorization": f"Bearer {token}"}
|
||||
|
||||
# 2. Consultar GET /admin/settings/all
|
||||
all_res = client.get("/api/v1/settings/all", headers=headers)
|
||||
assert all_res.status_code == 200
|
||||
all_data = all_res.json()
|
||||
assert "ai" in all_data["settings"]
|
||||
assert all_data["settings"]["ai"]["model"] == "qwen3-coder:30b"
|
||||
|
||||
# 3. Actualizar POST /admin/settings/ai
|
||||
update_res = client.post("/api/v1/settings/ai", headers=headers, json={
|
||||
"enabled": True,
|
||||
"base_url": "http://10.0.0.214:8080/v1",
|
||||
"api_key": "new_secret_key",
|
||||
"model": "qwen3-coder:30b",
|
||||
"model_name": "Qwen3 Coder 30B (Test)",
|
||||
"temperature": 0.25,
|
||||
"timeout": 45,
|
||||
"context_limit": 32768,
|
||||
"output_limit": 16384
|
||||
})
|
||||
assert update_res.status_code == 200
|
||||
assert update_res.json()["status"] == "success"
|
||||
|
||||
# Verificar persistencia en base de datos
|
||||
assert SystemSetting.get_value("ai_chat_model_name") == "Qwen3 Coder 30B (Test)"
|
||||
assert SystemSetting.get_decrypted_value("ai_chat_api_key") == "new_secret_key"
|
||||
|
||||
# 4. Probar conexión POST /admin/settings/ai/test con mock
|
||||
mock_models_resp = MagicMock()
|
||||
mock_models_resp.status_code = 200
|
||||
mock_models_resp.json.return_value = {
|
||||
"data": [{"id": "qwen3-coder:30b"}, {"id": "llama-3-8b"}]
|
||||
}
|
||||
|
||||
with patch("httpx.AsyncClient.get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_models_resp
|
||||
|
||||
test_res = client.post("/api/v1/settings/ai/test", headers=headers, json={
|
||||
"base_url": "http://10.0.0.214:8080/v1",
|
||||
"api_key": "new_secret_key"
|
||||
})
|
||||
assert test_res.status_code == 200
|
||||
test_data = test_res.json()
|
||||
assert test_data["status"] == "success"
|
||||
assert "qwen3-coder:30b" in test_data["models"]
|
||||
assert test_data["latency_ms"] is not None
|
||||
Reference in New Issue
Block a user