evolutia 0.1.0__py3-none-any.whl

evolutia/rag/rag_retriever.py

@@ -0,0 +1,366 @@
+"""
+RAG Retriever: Busca información relevante del vector store.
+"""
+import logging
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+
+try:
+    import chromadb
+    from chromadb.config import Settings
+    CHROMADB_AVAILABLE = True
+except ImportError:
+    CHROMADB_AVAILABLE = False
+
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+try:
+    from sentence_transformers import SentenceTransformer
+    SENTENCE_TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    SENTENCE_TRANSFORMERS_AVAILABLE = False
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+
+class RAGRetriever:
+    """Recupera información relevante del vector store."""
+    
+    def __init__(self, config: Dict[str, Any], base_path: Path, chroma_client=None):
+        """
+        Inicializa el retriever.
+        
+        Args:
+            config: Configuración de RAG desde config.yaml
+            base_path: Ruta base del proyecto
+            chroma_client: Cliente ChromaDB compartido (opcional)
+        """
+        self.config = config
+        self.base_path = Path(base_path)
+        self.embedding_provider = config.get('embeddings', {}).get('provider', 'openai')
+        self.chroma_client = chroma_client
+        self._setup_embeddings()
+        self._setup_vector_store()
+    
+    def _setup_embeddings(self):
+        """Configura el modelo de embeddings (debe coincidir con el indexer)."""
+        embeddings_config = self.config.get('embeddings', {})
+        provider = embeddings_config.get('provider', 'openai')
+        model_name = embeddings_config.get('model', 'text-embedding-3-small')
+        
+        if provider == 'openai':
+            if not OPENAI_AVAILABLE:
+                raise ImportError("openai no está instalado")
+            
+            api_key = os.getenv("OPENAI_API_KEY")
+            if not api_key:
+                raise ValueError("OPENAI_API_KEY no encontrada")
+            
+            self.embedding_client = OpenAI(api_key=api_key)
+            self.embedding_model_name = model_name
+        
+        elif provider == 'sentence-transformers':
+            if not SENTENCE_TRANSFORMERS_AVAILABLE:
+                raise ImportError("sentence-transformers no está instalado")
+            
+            self.embedding_model = SentenceTransformer(model_name)
+    
+    def _setup_vector_store(self):
+        """Configura la conexión al vector store."""
+        if not CHROMADB_AVAILABLE:
+            raise ImportError("chromadb no está instalado")
+        
+        vs_config = self.config.get('vector_store', {})
+        persist_dir = Path(vs_config.get('persist_directory', './storage/vector_store'))
+        collection_name = vs_config.get('collection_name', 'ejercicios_mmfi')
+        
+        # Usar cliente compartido si está disponible, sino crear uno nuevo
+        if self.chroma_client is not None:
+            self.client = self.chroma_client
+        else:
+            self.client = chromadb.PersistentClient(
+                path=str(persist_dir.resolve()),
+                settings=Settings(anonymized_telemetry=False)
+            )
+        
+        try:
+            self.collection = self.client.get_collection(name=collection_name)
+        except Exception as e:
+            raise ValueError(f"No se pudo cargar la colección {collection_name}. ¿Está indexado? Error: {e}")
+    
+    def _generate_query_embedding(self, query: str) -> List[float]:
+        """
+        Genera embedding para una consulta.
+        
+        Args:
+            query: Texto de consulta
+            
+        Returns:
+            Embedding del query
+        """
+        if self.embedding_provider == 'openai':
+            response = self.embedding_client.embeddings.create(
+                model=self.embedding_model_name,
+                input=query
+            )
+            return response.data[0].embedding
+        
+        elif self.embedding_provider == 'sentence-transformers':
+            return self.embedding_model.encode(query, show_progress_bar=False).tolist()
+    
+    def retrieve_similar_exercises(self, exercise_content: str, top_k: int = 5,
+                                   exclude_label: Optional[str] = None,
+                                   min_complexity: Optional[float] = None,
+                                   max_complexity: Optional[float] = None) -> List[Dict]:
+        """
+        Recupera ejercicios similares al contenido dado.
+        
+        Args:
+            exercise_content: Contenido del ejercicio de referencia
+            top_k: Número de resultados a recuperar
+            exclude_label: Label del ejercicio a excluir (el original)
+            min_complexity: Complejidad mínima
+            max_complexity: Complejidad máxima
+            
+        Returns:
+            Lista de ejercicios similares con sus metadatos
+        """
+        retrieval_config = self.config.get('retrieval', {})
+        top_k = retrieval_config.get('top_k', top_k)
+        similarity_threshold = retrieval_config.get('similarity_threshold', 0.7)
+        
+        # Generar embedding del query
+        query_embedding = self._generate_query_embedding(exercise_content)
+        
+        # Construir filtros de metadatos usando sintaxis correcta de ChromaDB
+        conditions = [{'type': 'exercise'}]
+        
+        if exclude_label:
+            conditions.append({'label': {'$ne': exclude_label}})
+        
+        if min_complexity is not None and max_complexity is not None:
+            conditions.append({'complexity': {'$gte': float(min_complexity)}})
+            conditions.append({'complexity': {'$lte': float(max_complexity)}})
+        elif min_complexity is not None:
+            conditions.append({'complexity': {'$gte': float(min_complexity)}})
+        elif max_complexity is not None:
+            conditions.append({'complexity': {'$lte': float(max_complexity)}})
+        
+        # Si hay múltiples condiciones, usar $and
+        if len(conditions) > 1:
+            where = {'$and': conditions}
+        elif len(conditions) == 1:
+            where = conditions[0]
+        else:
+            where = None
+        
+        # Buscar en el vector store
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k * 2,  # Buscar más para filtrar después
+            where=where
+        )
+        
+        # Procesar resultados
+        similar_exercises = []
+        
+        if results['ids'] and len(results['ids'][0]) > 0:
+            for i, (doc_id, doc, metadata, distance) in enumerate(zip(
+                results['ids'][0],
+                results['documents'][0],
+                results['metadatas'][0],
+                results['distances'][0]
+            )):
+                # Filtrar por umbral de similitud (distance es distancia, menor = más similar)
+                similarity = 1 - distance  # Convertir distancia a similitud
+                
+                if similarity >= similarity_threshold:
+                    similar_exercises.append({
+                        'id': doc_id,
+                        'content': doc,
+                        'metadata': metadata,
+                        'similarity': similarity,
+                        'distance': distance
+                    })
+                
+                if len(similar_exercises) >= top_k:
+                    break
+        
+        logger.info(f"Recuperados {len(similar_exercises)} ejercicios similares")
+        return similar_exercises
+    
+    def retrieve_related_concepts(self, concepts: List[str], top_k: int = 3) -> List[Dict]:
+        """
+        Recupera ejercicios o lecturas relacionados con conceptos específicos.
+        
+        Args:
+            concepts: Lista de conceptos a buscar
+            top_k: Número de resultados por concepto
+            
+        Returns:
+            Lista de documentos relacionados
+        """
+        query = f"Conceptos: {', '.join(concepts)}"
+        query_embedding = self._generate_query_embedding(query)
+        
+        retrieval_config = self.config.get('retrieval', {})
+        top_k_total = retrieval_config.get('top_k', top_k * len(concepts))
+        
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k_total
+        )
+        
+        related_docs = []
+        
+        if results['ids'] and len(results['ids'][0]) > 0:
+            for doc_id, doc, metadata, distance in zip(
+                results['ids'][0],
+                results['documents'][0],
+                results['metadatas'][0],
+                results['distances'][0]
+            ):
+                similarity = 1 - distance
+                related_docs.append({
+                    'id': doc_id,
+                    'content': doc,
+                    'metadata': metadata,
+                    'similarity': similarity
+                })
+        
+        logger.info(f"Recuperados {len(related_docs)} documentos relacionados con conceptos")
+        return related_docs
+    
+    def retrieve_reading_context(self, topic: str, top_k: int = 2) -> List[Dict]:
+        """
+        Recupera contexto de lecturas relacionadas con un tema.
+        
+        Args:
+            topic: Tema o concepto
+            top_k: Número de chunks de lectura a recuperar
+            
+        Returns:
+            Lista de chunks de lecturas
+        """
+        query_embedding = self._generate_query_embedding(topic)
+        
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k,
+            where={'type': 'reading'}
+        )
+        
+        reading_chunks = []
+        
+        if results['ids'] and len(results['ids'][0]) > 0:
+            for doc_id, doc, metadata, distance in zip(
+                results['ids'][0],
+                results['documents'][0],
+                results['metadatas'][0],
+                results['distances'][0]
+            ):
+                reading_chunks.append({
+                    'id': doc_id,
+                    'content': doc,
+                    'metadata': metadata,
+                    'similarity': 1 - distance
+                })
+        
+        logger.info(f"Recuperados {len(reading_chunks)} chunks de lecturas")
+        return reading_chunks
+    
+    def retrieve_by_complexity(self, target_complexity: float, tolerance: float = 0.2,
+                               top_k: int = 5) -> List[Dict]:
+        """
+        Recupera ejercicios con complejidad similar a la objetivo.
+        
+        Args:
+            target_complexity: Complejidad objetivo
+            tolerance: Tolerancia en la complejidad
+            top_k: Número de resultados
+            
+        Returns:
+            Lista de ejercicios con complejidad similar
+        """
+        min_complexity = target_complexity * (1 - tolerance)
+        max_complexity = target_complexity * (1 + tolerance)
+        
+        # Usar búsqueda por metadatos con sintaxis correcta de ChromaDB
+        where = {
+            '$and': [
+                {'type': 'exercise'},
+                {'complexity': {'$gte': float(min_complexity)}},
+                {'complexity': {'$lte': float(max_complexity)}}
+            ]
+        }
+        
+        results = self.collection.get(
+            where=where,
+            limit=top_k
+        )
+        
+        exercises = []
+        for i, (doc_id, doc, metadata) in enumerate(zip(
+            results['ids'],
+            results['documents'],
+            results['metadatas']
+        )):
+            exercises.append({
+                'id': doc_id,
+                'content': doc,
+                'metadata': metadata
+            })
+        
+        logger.info(f"Recuperados {len(exercises)} ejercicios por complejidad")
+        return exercises
+    
+    def hybrid_search(self, query: str, metadata_filters: Dict = None,
+                     top_k: int = 5) -> List[Dict]:
+        """
+        Búsqueda híbrida: semántica + filtros de metadatos.
+        
+        Args:
+            query: Consulta de texto
+            metadata_filters: Filtros de metadatos (ej: {'type': 'exercise'})
+            top_k: Número de resultados
+            
+        Returns:
+            Lista de resultados
+        """
+        query_embedding = self._generate_query_embedding(query)
+        
+        where = metadata_filters or {}
+        
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k,
+            where=where if where else None
+        )
+        
+        hybrid_results = []
+        
+        if results['ids'] and len(results['ids'][0]) > 0:
+            for doc_id, doc, metadata, distance in zip(
+                results['ids'][0],
+                results['documents'][0],
+                results['metadatas'][0],
+                results['distances'][0]
+            ):
+                hybrid_results.append({
+                    'id': doc_id,
+                    'content': doc,
+                    'metadata': metadata,
+                    'similarity': 1 - distance
+                })
+        
+        return hybrid_results
+

evolutia/utils/__init__.py

@@ -0,0 +1,4 @@
+"""
+Utilidades para el generador de exámenes.
+"""
+

evolutia/utils/json_parser.py

@@ -0,0 +1,69 @@
+"""
+Utilidades para parseo robusto de JSON, especialmente útil para respuestas de LLMs
+que pueden contener LaTeX o formatos markdown incorrectos.
+"""
+import json
+import re
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+def extract_and_parse_json(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Intenta extraer y parsear un objeto JSON de un texto arbitrario.
+    Maneja bloques de código markdown y errores comunes de escape en LaTeX.
+    """
+    if not text:
+        return None
+        
+    # 1. Limpieza básica y extracción de bloque de código
+    clean_text = text.strip()
+    
+    code_block_pattern = re.compile(r'```(?:json)?\s*(.*?)```', re.DOTALL)
+    match = code_block_pattern.search(clean_text)
+    
+    if match:
+        clean_text = match.group(1).strip()
+    
+    # HEURÍSTICA DE LATEX AGRESIVA
+    # En contextos matemáticos, secuencias como \frac, \textbf, \theta son muy comunes.
+    # json.loads interpreta \f, \b, \t como caracteres de control (form feed, backspace, tab).
+    # Esto corrompe el LaTeX (ej: \theta -> tab + heta).
+    # Por lo tanto, aplicamos una limpieza PREVIA al intento de parseo estándar para estas secuencias.
+    
+    # Whitelist de escapes que REALMENTE queremos preservar como controles JSON estándar:
+    # "  -> \" (comillas dentro de string)
+    # \  -> \\ (backslash literal ya escapado)
+    # /  -> \/ (forward slash escapado, opcional)
+    # n  -> \n (newline - muy común y necesario)
+    # r  -> \r (carriage return)
+    # u  -> \uXXXX (unicode - aunque \usepackage podría ser problematico, \u requiere 4 hex digits, asi que \usepackage falla json.loads y lo capturamos despues)
+    
+    # REMOVIDOS de whitelist (se escaparán a doble backslash):
+    # t  -> Para proteger \theta, \textbf, \text, etc.
+    # f  -> Para proteger \frac, \forall, etc.
+    # b  -> Para proteger \begin, \beta, etc.
+    
+    # Regex: Lookbehind negativo para asegurar que no está ya escapado (?<!\\)
+    # Lookahead negativo para permitir solo los de whitelist (?!["\\/nru])
+    # Así, \t se convierte en \\t (literal \t string), \n se queda como \n (control char).
+    
+    regex_latex_fix = r'(?<!\\)\\(?!["\\/nru])'
+    
+    try:
+        # Aplicar fix agresivo
+        fixed_text = re.sub(regex_latex_fix, r'\\\\', clean_text)
+        return json.loads(fixed_text, strict=False)
+    except json.JSONDecodeError:
+        # Si falla el fix agresivo (quizas rompió algo sutil, o el error es otro),
+        # intentamos el texto original con strict=False por si acaso era un newline issue
+        pass
+
+    try:
+        return json.loads(clean_text, strict=False)
+    except json.JSONDecodeError as e:
+        logger.debug(f"Fallo parseo JSON tras intentos: {e}")
+        
+    logger.error(f"No se pudo parsear JSON. Texto original (inicio): {text[:100]}...")
+    return None

evolutia/utils/markdown_parser.py

@@ -0,0 +1,160 @@
+"""
+Utilidades para parsear archivos Markdown/MyST y extraer ejercicios y soluciones.
+"""
+import re
+import yaml
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+def extract_frontmatter(content: str) -> Tuple[Dict, str]:
+    """
+    Extrae el frontmatter YAML del contenido Markdown.
+    
+    Args:
+        content: Contenido completo del archivo
+        
+    Returns:
+        Tupla (frontmatter_dict, contenido_sin_frontmatter)
+    """
+    frontmatter_pattern = r'^---\s*\n(.*?)\n---\s*\n'
+    match = re.match(frontmatter_pattern, content, re.DOTALL)
+    
+    if match:
+        frontmatter_str = match.group(1)
+        try:
+            frontmatter = yaml.safe_load(frontmatter_str) or {}
+            content_without_frontmatter = content[match.end():]
+            return frontmatter, content_without_frontmatter
+        except yaml.YAMLError:
+            return {}, content
+    return {}, content
+
+
+def extract_exercise_blocks(content: str) -> List[Dict]:
+    """
+    Extrae bloques de ejercicio del formato MyST.
+    
+    Busca bloques del tipo:
+    ```{exercise} N
+    :label: exN-XX
+    ...
+    ```
+    
+    Args:
+        content: Contenido Markdown
+        
+    Returns:
+        Lista de diccionarios con información de cada ejercicio
+    """
+    exercises = []
+    
+    # Patrón para bloques de ejercicio MyST
+    # Captura delimitador (grupo 1), label (grupo 2) y contenido (grupo 3)
+    # Usa backreference \1 para coincidir con la longitud exacta del delimitador de cierre
+    exercise_pattern = r'(`{3,4})\{exercise\}(?:\s+\d+)?\s*\n:label:\s+(\S+)\s*\n(.*?)(?=\1)'
+    
+    matches = re.finditer(exercise_pattern, content, re.DOTALL)
+    
+    for match in matches:
+        # group(1) es el delimitador
+        label = match.group(2)
+        exercise_content = match.group(3).strip()
+        
+        # Buscar si hay un include dentro
+        include_match = re.search(r'```\{include\}\s+(.+?)\s*```', exercise_content, re.DOTALL)
+        if include_match:
+            include_path = include_match.group(1).strip()
+            exercises.append({
+                'label': label,
+                'content': exercise_content,
+                'include_path': include_path,
+                'type': 'include'
+            })
+        else:
+            exercises.append({
+                'label': label,
+                'content': exercise_content,
+                'include_path': None,
+                'type': 'inline'
+            })
+    
+    return exercises
+
+
+def extract_solution_blocks(content: str) -> List[Dict]:
+    """
+    Extrae bloques de solución del formato MyST.
+    
+    Busca bloques del tipo:
+    ````{solution} exN-XX
+    :label: solution-exN-XX
+    ...
+    ````
+    
+    Args:
+        content: Contenido Markdown
+        
+    Returns:
+        Lista de diccionarios con información de cada solución
+    """
+    solutions = []
+    
+    # Patrón para bloques de solución MyST
+    # Captura delimitador (grupo 1), exercise_label (grupo 2), solution_label (grupo 3), contenido (grupo 4)
+    solution_pattern = r'(`{3,4})\{solution\}\s+(\S+)\s*\n:label:\s+(\S+)\s*\n(.*?)(?=\1)'
+    
+    matches = re.finditer(solution_pattern, content, re.DOTALL)
+    
+    for match in matches:
+        # group(1) es delimitador
+        exercise_label = match.group(2)
+        solution_label = match.group(3)
+        solution_content = match.group(4).strip()
+        
+        # Buscar includes dentro de la solución
+        include_matches = re.finditer(r'```\{include\}\s+(.+?)\s*```', solution_content, re.DOTALL)
+        include_paths = [m.group(1).strip() for m in include_matches]
+        
+        solutions.append({
+            'exercise_label': exercise_label,
+            'label': solution_label,
+            'content': solution_content,
+            'include_paths': include_paths
+        })
+    
+    return solutions
+
+
+def read_markdown_file(file_path: Path) -> str:
+    """
+    Lee un archivo Markdown y retorna su contenido.
+    
+    Args:
+        file_path: Ruta al archivo
+        
+    Returns:
+        Contenido del archivo
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        raise IOError(f"Error leyendo archivo {file_path}: {e}")
+
+
+def resolve_include_path(include_path: str, base_dir: Path) -> Path:
+    """
+    Resuelve una ruta de include relativa a un directorio base.
+    
+    Args:
+        include_path: Ruta relativa del include
+        base_dir: Directorio base
+        
+    Returns:
+        Ruta absoluta resuelta
+    """
+    # Limpiar la ruta (puede tener ./ o espacios)
+    clean_path = include_path.strip().lstrip('./')
+    return (base_dir / clean_path).resolve()
+