How javitrucas/chatbot_ia_ceprud works
Identificación del tipo de proyecto y su propósito
• Se trata de un chatbot basado en IA para CEPRUD, implementado como una aplicación full-stack ligera.
• Combina un frontend web (HTML/CSS/JS), una API REST en Python y un motor RAG (Retrieval-Augmented Generation) con fine-tuning QLoRA para generar respuestas.
• Incluye además pipelines de preprocesamiento, generación de embeddings, población de base de datos, entrenamiento y visualización de métricas.
Análisis de la estructura de ficheros
• Top-level scripts:
• app.py, api.py: punto de entrada del backend y definición de endpoints REST.
• generate_data.py, get_embedding_function.py, populate_database.py: pipeline de datos para RAG.
• finetuning_qlora.py, finetuned-model_test.py: fine-tuning y tests de QLoRA.
• script_graphs.py: generación de gráficos de métricas.
• Directorios claves:
• data/: corpus de documentos y JSON de entrenamiento.
• models/: modelos base, adaptadores QLoRA y checkpoints.
• templates/, static/: frontend web (HTML, CSS).
• logs/, graphs/: almacenamiento de logs de chat y gráficos generados.
• Tests automáticos en archivos test_*.py.
Insights del README
• Usa RAG con embeddings + recuperación de documentos.
• La API REST es ligera y sirve el chatbot a través de app.py y api.py.
• Soporta fine-tuning con QLoRA para dominios específicos.
• Ofrece un demo frontend básico y generación de logs/métricas.
Componentes principales a representar en el diagrama
a. Frontend web:
• Navegador ▶ plantillas HTML (templates/index.html) + CSS/JS (static/).
b. Backend/API:
• app.py (servidor web, Flask/FastAPI)
• api.py (endpoints RAG: /chat, /metrics, etc.)
• query_logic.py (lógica que orquesta embedding, recuperación e inferencia).
c. Pipeline de datos y RAG:
• generate_data.py → limpieza/transformación de datos.
• get_embedding_function.py → función de generación de embeddings.
• populate_database.py → construcción de base de datos vectorial.
d. Base de datos de vectores y documentos:
• Almacenamiento local o servicio embebido para RAG.
e. Motor de inferencia:
• Modelos QLoRA en models/...-deepseek-qlora
• Llamada al LLM base (p.ej. Hugging Face) + adaptador QLoRA.
f. Módulo de fine-tuning:
• finetuning_qlora.py y checkpoints en models/.../checkpoint-*.
g. Logs y métricas:
• logs/chat_logs.csv + gráficos generados por script_graphs.py, almacenados en graphs/.
Relación e interacción entre componentes
• Flujo de usuario:
Usuario ▶ Frontend ▶ HTTP POST /chat ▶ Backend/API ▶ query_logic.py
├─> Embedding ▶ Base vectorial (RAG) ▶ documentos
└─> Llamada a LLM adaptado (QLoRA) ▶ respuesta
▶ API devuelve JSON al Frontend ▶ se muestra en la interfaz.
• Flujo de datos y training:
generate_data.py ▶ datos limpios ▶ get_embedding_function.py ▶ embeddings
▶ populate_database.py ▶ base vectorial
▶ finetuning_qlora.py ▶ nuevos modelos en models/ ▶ tests con finetuned-model_test.py.
• Flujo de métricas:
Logs de chat (CSV) ▶ script_graphs.py ▶ gráficos en graphs/.
Patrones y principios arquitectónicos
• Separación de capas: UI / API / lógica de negocio / persistencia de vectores / modelos ML.
• Pipeline ETL para ingestión y recuperación de datos.
• Microservicio ligero (API REST) para desacoplar frontend y backend de ML.
• Diseño modular: scripts y módulos independientes por responsabilidad.
Guía para dibujar el diagrama
• Utilizar cajas (rectángulos) para cada componente: Frontend, API, Lógica RAG, Vector DB, Model Store, ETL, Logs/Métricas.
• Flechas direccionales:
• Flujo de usuario (Front ▶ API ▶ RAG ▶ Modelos ▶ API ▶ Front).
• Flujo de datos (ETL ▶ Vector DB).
• Flujo de entrenamiento (Data ▶ Fine-tuning ▶ Model Store).
• Flujo de generación de métricas (Logs ▶ Script Graphs ▶ Graphs).
• Colores o formas distintas:
• Azul para componentes web/API.
• Verde para pipelines de datos/RAG.
• Naranja para modelos ML.
• Gris para almacenamiento (logs, base de datos, gráficos).
• Etiquetar claramente cada flecha con la acción o el tipo de dato que transporta (por ejemplo, “embedding request”, “vector lookup”, “chat response”).
Recomendaciones finales
• Mantener el diagrama limpio y legible, agrupando componentes relacionados.
• Numerar o usar leyenda si hay muchos subprocesos (ETL, training, inference).
• Verificar que todos los scripts y directorios del proyecto estén representados según su rol.
• Revisar la dirección de las flechas para que el flujo sea intuitivo de izquierda a derecha o de arriba a abajo.
Con estas indicaciones, se obtiene un diagrama detallado y organizado, adaptado al proyecto Chatbot_IA_Ceprud, donde las flechas muestran claramente el flujo de datos y las interacciones entre frontend, backend, pipeline RAG y módulos de ML.