evolutia 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

evolutia/evolutia_engine.py

@@ -11,40 +11,40 @@ import time
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple, Any, Union
 from tqdm import tqdm
-
-# Imports from internal modules
-from .material_extractor import MaterialExtractor
-from .exercise_analyzer import ExerciseAnalyzer
-from .variation_generator import VariationGenerator
-from .complexity_validator import ComplexityValidator
-from .exam_generator import ExamGenerator
-from .config_manager import ConfigManager
-
-# Conditional RAG imports
-try:
-    from .rag.rag_manager import RAGManager
-    from .rag.enhanced_variation_generator import EnhancedVariationGenerator
-    from .rag.consistency_validator import ConsistencyValidator
-    RAG_AVAILABLE = True
-except ImportError:
-    RAG_AVAILABLE = False
-
-logger = logging.getLogger(__name__)
-
-class EvolutiaEngine:
-    """
-    Motor central que coordina el flujo de trabajo de EvolutIA.
-    """
-
+
+# Imports from internal modules
+from .material_extractor import MaterialExtractor
+from .exercise_analyzer import ExerciseAnalyzer
+from .variation_generator import VariationGenerator
+from .complexity_validator import ComplexityValidator
+from .exam_generator import ExamGenerator
+from .config_manager import ConfigManager
+
+# Conditional RAG imports
+try:
+    from .rag.rag_manager import RAGManager
+    from .rag.enhanced_variation_generator import EnhancedVariationGenerator
+    from .rag.consistency_validator import ConsistencyValidator
+    RAG_AVAILABLE = True
+except ImportError:
+    RAG_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+class EvolutiaEngine:
+    """
+    Motor central que coordina el flujo de trabajo de EvolutIA.
+    """
+
     def __init__(self, base_path: Union[Path, str], config_path: Optional[Union[Path, str]] = None):
         self.base_path = Path(base_path)
         self.config_path = Path(config_path) if config_path else None
         self.rag_manager = None
-        
-        # Load configuration manager
-        self.config_manager = ConfigManager(base_path, config_path)
-        self.full_config = self.config_manager.load_current_config()
-
+        
+        # Load configuration manager
+        self.config_manager = ConfigManager(base_path, config_path)
+        self.full_config = self.config_manager.load_current_config()
+
     def initialize_rag(self, force_reindex: bool = False) -> bool:
         """
         Inicializa el subsistema RAG si está disponible.
@@ -65,70 +65,70 @@ class EvolutiaEngine:
         except Exception as e:
             logger.error(f"[EvolutiaEngine] Error inicializando RAG (force_reindex={force_reindex}): {e}")
             return False
-
-    def get_api_config(self, provider: str) -> Dict[str, Any]:
-        """Obtiene la configuración específica para una API."""
-        return self.full_config.get('api', {}).get(provider, {})
-
-    def extract_materials_and_exercises(self, topics: List[str], label_filter: Optional[List[str]] = None) -> Tuple[List[Dict], List[Dict]]:
-        """
-        Paso 1 & 2: Extrae materiales y lista todos los ejercicios disponibles.
-        """
-        logger.info("Paso 1: Extrayendo materiales didácticos...")
-        extractor = MaterialExtractor(self.base_path)
-        materials = []
-
-        # 1. Extract by topic
-        if topics:
-            for topic in topics:
-                topic_materials = extractor.extract_by_topic(topic)
-                if topic_materials:
-                    materials.extend(topic_materials)
-                else:
-                    logger.warning(f"No se encontraron materiales para el tema: {topic}")
-        
-        # 2. Fallback: Search all if no materials found yet or topics were empty (e.g., list mode)
-        if not materials:
-            logger.info("Buscando en todos los directorios...")
-            for topic_dir in self.base_path.iterdir():
-                if topic_dir.is_dir() and topic_dir.name not in ['_build', 'evolutia', 'proyecto', '.git']:
-                    materials.extend(extractor.extract_from_directory(topic_dir))
-        
-        if not materials:
-            return [], []
-
-        logger.info(f"Encontrados {len(materials)} archivos con materiales")
-        
-        # Get exercises
-        logger.info("Paso 2: Obteniendo ejercicios...")
-        all_exercises = extractor.get_all_exercises(materials)
-        
-        # Filter by label if requested
-        if label_filter:
-            logger.info(f"Filtrando por labels: {label_filter}")
-            filtered = [ex for ex in all_exercises if ex.get('label') in label_filter]
-            if not filtered:
-                available = [ex.get('label') for ex in all_exercises if ex.get('label')]
-                logger.warning(f"No se encontraron ejercicios con los labels solicitados. Disponibles: {available[:10]}...")
-            all_exercises = filtered
-            
-        logger.info(f"Encontrados {len(all_exercises)} ejercicios")
-        return materials, all_exercises
-
-    def analyze_exercises(self, exercises: List[Dict]) -> List[Tuple[Dict, Dict]]:
-        """Paso 3: Analiza la complejidad de los ejercicios."""
-        logger.info("Paso 3: Analizando complejidad de ejercicios...")
-        analyzer = ExerciseAnalyzer()
-        exercises_with_analysis = []
-        
-        for exercise in exercises:
-            analysis = analyzer.analyze(exercise)
-            exercises_with_analysis.append((exercise, analysis))
-            
-        # Sort by total complexity descending
-        exercises_with_analysis.sort(key=lambda x: x[1]['total_complexity'], reverse=True)
-        return exercises_with_analysis
-
+
+    def get_api_config(self, provider: str) -> Dict[str, Any]:
+        """Obtiene la configuración específica para una API."""
+        return self.full_config.get('api', {}).get(provider, {})
+
+    def extract_materials_and_exercises(self, topics: List[str], label_filter: Optional[List[str]] = None) -> Tuple[List[Dict], List[Dict]]:
+        """
+        Paso 1 & 2: Extrae materiales y lista todos los ejercicios disponibles.
+        """
+        logger.info("Paso 1: Extrayendo materiales didácticos...")
+        extractor = MaterialExtractor(self.base_path)
+        materials = []
+
+        # 1. Extract by topic
+        if topics:
+            for topic in topics:
+                topic_materials = extractor.extract_by_topic(topic)
+                if topic_materials:
+                    materials.extend(topic_materials)
+                else:
+                    logger.warning(f"No se encontraron materiales para el tema: {topic}")
+        
+        # 2. Fallback: Search all if no materials found yet or topics were empty (e.g., list mode)
+        if not materials:
+            logger.info("Buscando en todos los directorios...")
+            for topic_dir in self.base_path.iterdir():
+                if topic_dir.is_dir() and topic_dir.name not in ['_build', 'evolutia', 'proyecto', '.git']:
+                    materials.extend(extractor.extract_from_directory(topic_dir))
+        
+        if not materials:
+            return [], []
+
+        logger.info(f"Encontrados {len(materials)} archivos con materiales")
+        
+        # Get exercises
+        logger.info("Paso 2: Obteniendo ejercicios...")
+        all_exercises = extractor.get_all_exercises(materials)
+        
+        # Filter by label if requested
+        if label_filter:
+            logger.info(f"Filtrando por labels: {label_filter}")
+            filtered = [ex for ex in all_exercises if ex.get('label') in label_filter]
+            if not filtered:
+                available = [ex.get('label') for ex in all_exercises if ex.get('label')]
+                logger.warning(f"No se encontraron ejercicios con los labels solicitados. Disponibles: {available[:10]}...")
+            all_exercises = filtered
+            
+        logger.info(f"Encontrados {len(all_exercises)} ejercicios")
+        return materials, all_exercises
+
+    def analyze_exercises(self, exercises: List[Dict]) -> List[Tuple[Dict, Dict]]:
+        """Paso 3: Analiza la complejidad de los ejercicios."""
+        logger.info("Paso 3: Analizando complejidad de ejercicios...")
+        analyzer = ExerciseAnalyzer()
+        exercises_with_analysis = []
+        
+        for exercise in exercises:
+            analysis = analyzer.analyze(exercise)
+            exercises_with_analysis.append((exercise, analysis))
+            
+        # Sort by total complexity descending
+        exercises_with_analysis.sort(key=lambda x: x[1]['total_complexity'], reverse=True)
+        return exercises_with_analysis
+
     def _generate_single_variation(
         self,
         generator: Union['VariationGenerator', 'EnhancedVariationGenerator'],
@@ -138,43 +138,46 @@ class EvolutiaEngine:
         args: argparse.Namespace
     ) -> Optional[Dict]:
         """Helper para generar una única variación (thread-safe logic)."""
-        attempt_count = 0
-        while attempt_count < 3:
-            try:
-                # Generate
-                if args.type == 'multiple_choice':
-                    variation = generator.generate_variation(
-                        exercise_base, 
-                        analysis, 
-                        exercise_type=args.type
-                    )
-                elif not args.no_generar_soluciones:
-                    variation = generator.generate_variation_with_solution(
-                        exercise_base, 
-                        analysis
-                    )
-                else:
-                    variation = generator.generate_variation(
-                        exercise_base, 
-                        analysis, 
-                        exercise_type=args.type
-                    )
-                
-                if not variation:
-                    attempt_count += 1
-                    continue
-
-                # Validate
-                if args.use_rag:
-                    validation = validator.validate(exercise_base, analysis, variation)
-                    is_valid = validation['is_valid']
-                else:
-                    validation = validator.validate(exercise_base, analysis, variation)
-                    is_valid = validation['is_valid']
-                
-                if is_valid:
-                    return variation
-                
+        attempt_count = 0
+        while attempt_count < 3:
+            try:
+                # Generate
+                if args.type == 'multiple_choice':
+                    variation = generator.generate_variation(
+                        exercise_base, 
+                        analysis, 
+                        exercise_type=args.type,
+                        max_tokens=args.max_tokens
+                    )
+                elif not args.no_generar_soluciones:
+                    variation = generator.generate_variation_with_solution(
+                        exercise_base, 
+                        analysis,
+                        max_tokens=args.max_tokens
+                    )
+                else:
+                    variation = generator.generate_variation(
+                        exercise_base, 
+                        analysis, 
+                        exercise_type=args.type,
+                        max_tokens=args.max_tokens
+                    )
+                
+                if not variation:
+                    attempt_count += 1
+                    continue
+
+                # Validate
+                if args.use_rag:
+                    validation = validator.validate(exercise_base, analysis, variation)
+                    is_valid = validation['is_valid']
+                else:
+                    validation = validator.validate(exercise_base, analysis, variation)
+                    is_valid = validation['is_valid']
+                
+                if is_valid:
+                    return variation
+                
             except Exception as e:
                 logger.error(f"[EvolutiaEngine] Error en hilo de generación (intento {attempt_count + 1}/3): {e}")
 
@@ -188,7 +191,8 @@ class EvolutiaEngine:
         topic: str,
         tags: List[str],
         complexity: str,
-        ex_type: str
+        ex_type: str,
+        args: argparse.Namespace
     ) -> Optional[Dict]:
         """
         Helper para modo creación.
@@ -202,12 +206,13 @@ class EvolutiaEngine:
                 topic,
                 tags,
                 difficulty=complexity,
-                exercise_type=ex_type
+                exercise_type=ex_type,
+                max_tokens=args.max_tokens
             )
         except Exception as e:
             logger.error(f"[EvolutiaEngine] Error en creación de ejercicio nuevo (topic={topic}): {e}")
             return None
-
+
     def generate_variations_parallel(
         self,
         selected_exercises: List[Tuple[Dict, Dict]],
@@ -217,83 +222,83 @@ class EvolutiaEngine:
         """
         Paso 4: Genera variaciones en paralelo.
         """
-        logger.info(f"Paso 4: Generando variaciones en paralelo (Workers: {max_workers})...")
-        
-        # Setup Generator
-        api_config = self.get_api_config(args.api)
-        
-        if (args.use_rag and self.rag_manager) or args.mode == 'creation':
-            retriever = self.rag_manager.get_retriever() if (args.use_rag and self.rag_manager) else None
-            generator = EnhancedVariationGenerator(api_provider=args.api, retriever=retriever)
-            validator = ConsistencyValidator(retriever=retriever) if retriever else ComplexityValidator()
-        else:
-            generator = VariationGenerator(api_provider=args.api)
-            validator = ComplexityValidator()
-
-        # Configure model
-        if args.api == 'local':
-            generator.base_url = args.base_url or api_config.get('base_url', "http://localhost:11434/v1")
-            generator.local_model = args.model or api_config.get('model', "llama3")
-        elif args.api == 'generic':
-            generator.base_url = args.base_url or api_config.get('base_url')
-            generator.model_name = args.model or api_config.get('model')
-        elif args.api in ['openai', 'anthropic', 'deepseek', 'gemini']:
-            if args.model:
-                 generator.model_name = args.model
-            elif 'model' in api_config:
-                generator.model_name = api_config['model']
-
-        # Determine tasks based on mode
-        tasks = []
-        
-        if args.mode == 'creation':
-            # Creation Mode Logic
-            for i in range(args.num_ejercicios):
-                current_topic = args.tema[i % len(args.tema)]
-                current_tags = [args.tags[i % len(args.tags)]] if args.tags else [current_topic]
-                
-                tasks.append({
-                    'func': self._generate_creation_mode,
-                    'args': (generator, current_topic, current_tags, args.complejidad, args.type)
-                })
-        else:
-            # Variation Mode Logic
-            
-            # If explicit lables, use exactly those
-            if args.label:
-                target_exercises = list(selected_exercises)
-            else:
-                 # Random selection to fill num_ejercicios
-                 target_exercises = []
-                 candidates = selected_exercises[:max(5, len(selected_exercises)//2)]
-                 for _ in range(args.num_ejercicios):
-                     if candidates:
-                        target_exercises.append(random.choice(candidates))
-
-            for ex_base, analysis in target_exercises:
-                tasks.append({
-                    'func': self._generate_single_variation,
-                    'args': (generator, validator, ex_base, analysis, args)
-                })
-
-        # Execute Parallel
-        valid_variations = []
-        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_task = {}
-            for t in tasks:
-                future = executor.submit(t['func'], *t['args'])
-                future_to_task[future] = t
-                # Stagger requests to avoid hitting rate limits instantly
-                time.sleep(1.0) 
-            
-            for future in tqdm(concurrent.futures.as_completed(future_to_task), total=len(tasks), desc="Generando"):
-                try:
-                    result = future.result()
-                    if result:
-                        valid_variations.append(result)
-                except Exception as e:
-                    logger.error(f"Excepción no manejada en worker: {e}")
-
+        logger.info(f"Paso 4: Generando variaciones en paralelo (Workers: {max_workers})...")
+        
+        # Setup Generator
+        api_config = self.get_api_config(args.api)
+        
+        if (args.use_rag and self.rag_manager) or args.mode == 'creation':
+            retriever = self.rag_manager.get_retriever() if (args.use_rag and self.rag_manager) else None
+            generator = EnhancedVariationGenerator(api_provider=args.api, retriever=retriever)
+            validator = ConsistencyValidator(retriever=retriever) if retriever else ComplexityValidator()
+        else:
+            generator = VariationGenerator(api_provider=args.api)
+            validator = ComplexityValidator()
+
+        # Configure model
+        if args.api == 'local':
+            generator.base_url = args.base_url or api_config.get('base_url', "http://localhost:11434/v1")
+            generator.local_model = args.model or api_config.get('model', "llama3")
+        elif args.api == 'generic':
+            generator.base_url = args.base_url or api_config.get('base_url')
+            generator.model_name = args.model or api_config.get('model')
+        elif args.api in ['openai', 'anthropic', 'deepseek', 'gemini']:
+            if args.model:
+                 generator.model_name = args.model
+            elif 'model' in api_config:
+                generator.model_name = api_config['model']
+
+        # Determine tasks based on mode
+        tasks = []
+        
+        if args.mode == 'creation':
+            # Creation Mode Logic
+            for i in range(args.num_ejercicios):
+                current_topic = args.tema[i % len(args.tema)]
+                current_tags = [args.tags[i % len(args.tags)]] if args.tags else [current_topic]
+                
+                tasks.append({
+                    'func': self._generate_creation_mode,
+                    'args': (generator, current_topic, current_tags, args.complejidad, args.type, args)
+                })
+        else:
+            # Variation Mode Logic
+            
+            # If explicit lables, use exactly those
+            if args.label:
+                target_exercises = list(selected_exercises)
+            else:
+                 # Random selection to fill num_ejercicios
+                 target_exercises = []
+                 candidates = selected_exercises[:max(5, len(selected_exercises)//2)]
+                 for _ in range(args.num_ejercicios):
+                     if candidates:
+                        target_exercises.append(random.choice(candidates))
+
+            for ex_base, analysis in target_exercises:
+                tasks.append({
+                    'func': self._generate_single_variation,
+                    'args': (generator, validator, ex_base, analysis, args)
+                })
+
+        # Execute Parallel
+        valid_variations = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_task = {}
+            for t in tasks:
+                future = executor.submit(t['func'], *t['args'])
+                future_to_task[future] = t
+                # Stagger requests to avoid hitting rate limits instantly
+                time.sleep(1.0) 
+            
+            for future in tqdm(concurrent.futures.as_completed(future_to_task), total=len(tasks), desc="Generando"):
+                try:
+                    result = future.result()
+                    if result:
+                        valid_variations.append(result)
+                except Exception as e:
+                    logger.error(f"Excepción no manejada en worker: {e}")
+
         logger.info(f"Generación completada. {len(valid_variations)} variaciones exitosas.")
         return valid_variations
 
@@ -332,14 +337,16 @@ class EvolutiaEngine:
                             generator.generate_variation,
                             exercise_base,
                             analysis,
-                            args.type
+                            exercise_type=args.type,
+                            max_tokens=args.max_tokens
                         )
                     elif not args.no_generar_soluciones:
                         variation = await loop.run_in_executor(
                             None,
                             generator.generate_variation_with_solution,
                             exercise_base,
-                            analysis
+                            analysis,
+                            max_tokens=args.max_tokens
                         )
                     else:
                         variation = await loop.run_in_executor(
@@ -347,7 +354,8 @@ class EvolutiaEngine:
                             generator.generate_variation,
                             exercise_base,
                             analysis,
-                            args.type
+                            exercise_type=args.type,
+                            max_tokens=args.max_tokens
                         )
 
                     if not variation:
@@ -381,6 +389,7 @@ class EvolutiaEngine:
         tags: List[str],
         complexity: str,
         ex_type: str,
+        args: argparse.Namespace,
         semaphore: asyncio.Semaphore
     ) -> Optional[Dict]:
         """
@@ -399,7 +408,8 @@ class EvolutiaEngine:
                     topic,
                     tags,
                     complexity,
-                    ex_type
+                    ex_type,
+                    args.max_tokens
                 )
             except Exception as e:
                 logger.error(f"[EvolutiaEngine] Error en async creación (topic={topic}): {e}")
@@ -463,7 +473,8 @@ class EvolutiaEngine:
                     current_topic,
                     current_tags,
                     args.complejidad,
-                    args.type
+                    args.type,
+                    args.max_tokens
                 ))
         else:
             if args.label:
@@ -498,6 +509,7 @@ class EvolutiaEngine:
                     task_info[3],  # tags
                     task_info[4],  # complexity
                     task_info[5],  # ex_type
+                    task_info[6],  # max_tokens
                     semaphore
                 ))
             else:
@@ -528,7 +540,7 @@ class EvolutiaEngine:
 
         logger.info(f"Generación async completada. {len(valid_variations)} variaciones exitosas.")
         return valid_variations
-
+
     def generate_exam_files(
         self,
         variations: List[Dict],
@@ -537,23 +549,23 @@ class EvolutiaEngine:
         exam_number: int
     ) -> bool:
         """Paso 5: Genera los archivos finales del examen."""
-        logger.info("Paso 5: Generando archivos de examen...")
-        exam_gen = ExamGenerator(self.base_path)
-        
-        keywords = args.keywords or []
-        metadata = {
-            'model': args.api, # Simplified, internal details hidden
-            'provider': args.api,
-            'rag_enabled': args.use_rag,
-            'mode': args.mode,
-            'target_difficulty': args.complejidad
-        }
-        
-        return exam_gen.generate_exam(
-            variations,
-            exam_number,
-            output_dir,
-            args.subject,
-            keywords,
-            metadata=metadata
-        )
+        logger.info("Paso 5: Generando archivos de examen...")
+        exam_gen = ExamGenerator(self.base_path)
+        
+        keywords = args.keywords or []
+        metadata = {
+            'model': args.api, # Simplified, internal details hidden
+            'provider': args.api,
+            'rag_enabled': args.use_rag,
+            'mode': args.mode,
+            'target_difficulty': args.complejidad
+        }
+        
+        return exam_gen.generate_exam(
+            variations,
+            exam_number,
+            output_dir,
+            args.subject,
+            keywords,
+            metadata=metadata
+        )

evolutia/llm_providers.py

@@ -142,8 +142,20 @@ class OpenAICompatibleProvider(LLMProvider):
                 temperature=kwargs.get("temperature", self.DEFAULT_TEMPERATURE),
                 max_tokens=kwargs.get("max_tokens", self.DEFAULT_MAX_TOKENS)
             )
-            content = response.choices[0].message.content.strip()
-            logger.info(f"[{provider_name}] Contenido generado exitosamente (modelo={model}, longitud={len(content)})")
+            message = response.choices[0].message
+            finish_reason = response.choices[0].finish_reason
+            
+            if hasattr(message, 'content') and message.content is not None:
+                content = message.content.strip()
+            else:
+                content = ""
+                logger.warning(f"[{provider_name}] Message content is None")
+
+            if not content:
+                logger.warning(f"[{provider_name}] Contenido vacío recibido. Finish reason: {finish_reason}")
+                logger.debug(f"[{provider_name}] Raw response: {response}")
+
+            logger.info(f"[{provider_name}] Contenido generado exitosamente (modelo={model}, longitud={len(content)}, reason={finish_reason})")
 
             # Guardar en caché
             if self.cache:

evolutia/schemas/config.schema.json

@@ -0,0 +1,210 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Evolutia Configuration",
+    "description": "Configuration schema for Evolutia AI tool",
+    "type": "object",
+    "properties": {
+        "api": {
+            "type": "object",
+            "properties": {
+                "default_provider": {
+                    "type": "string"
+                },
+                "openai": {
+                    "$ref": "#/definitions/modelConfig"
+                },
+                "anthropic": {
+                    "$ref": "#/definitions/modelConfig"
+                },
+                "gemini": {
+                    "$ref": "#/definitions/modelConfig"
+                },
+                "local": {
+                    "allOf": [
+                        {
+                            "$ref": "#/definitions/modelConfig"
+                        },
+                        {
+                            "properties": {
+                                "base_url": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    ]
+                }
+            },
+            "required": [
+                "default_provider"
+            ]
+        },
+        "paths": {
+            "type": "object",
+            "properties": {
+                "base_path": {
+                    "type": "string"
+                },
+                "materials_directories": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "materials_directories"
+            ]
+        },
+        "complexity": {
+            "type": "object",
+            "properties": {
+                "min_complexity_increase": {
+                    "type": "number"
+                },
+                "min_improvements": {
+                    "type": "integer"
+                },
+                "weights": {
+                    "type": "object",
+                    "patternProperties": {
+                        "^.*$": {
+                            "type": "number"
+                        }
+                    }
+                }
+            }
+        },
+        "exam": {
+            "type": "object",
+            "properties": {
+                "default": {
+                    "type": "object",
+                    "properties": {
+                        "subject": {
+                            "type": "string"
+                        },
+                        "points_per_exercise": {
+                            "type": "integer"
+                        },
+                        "duration_hours": {
+                            "type": "number"
+                        }
+                    }
+                },
+                "keywords": {
+                    "type": "object",
+                    "patternProperties": {
+                        "^.*$": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "logging": {
+            "type": "object",
+            "properties": {
+                "level": {
+                    "type": "string"
+                },
+                "format": {
+                    "type": "string"
+                }
+            }
+        },
+        "rag": {
+            "type": "object",
+            "properties": {
+                "vector_store": {
+                    "type": "object",
+                    "properties": {
+                        "type": {
+                            "type": "string"
+                        },
+                        "persist_directory": {
+                            "type": "string"
+                        },
+                        "collection_name": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "type"
+                    ]
+                },
+                "embeddings": {
+                    "type": "object",
+                    "properties": {
+                        "provider": {
+                            "type": "string"
+                        },
+                        "model": {
+                            "type": "string"
+                        },
+                        "batch_size": {
+                            "type": "integer"
+                        }
+                    },
+                    "required": [
+                        "provider",
+                        "model"
+                    ]
+                },
+                "retrieval": {
+                    "type": "object",
+                    "properties": {
+                        "top_k": {
+                            "type": "integer"
+                        },
+                        "similarity_threshold": {
+                            "type": "number"
+                        },
+                        "use_metadata_filters": {
+                            "type": "boolean"
+                        }
+                    }
+                },
+                "chunking": {
+                    "type": "object",
+                    "properties": {
+                        "chunk_size": {
+                            "type": "integer"
+                        },
+                        "chunk_overlap": {
+                            "type": "integer"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "required": [
+        "api",
+        "paths"
+    ],
+    "definitions": {
+        "modelConfig": {
+            "type": "object",
+            "properties": {
+                "model": {
+                    "type": "string"
+                },
+                "temperature": {
+                    "type": "number"
+                },
+                "max_tokens": {
+                    "type": "integer"
+                },
+                "api_key": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "model"
+            ]
+        }
+    }
+}

evolutia/validation/__init__.py

@@ -1 +1,2 @@
-# Tests package for EvolutIA validation
+from .config_validator import ConfigValidator, ConfigValidationError
+from .args_validator import ArgsValidator

evolutia/variation_generator.py

@@ -1,22 +1,22 @@
-"""
-Generador de variaciones de ejercicios con mayor complejidad.
-Utiliza APIs de IA para generar variaciones inteligentes.
-"""
-import os
-import logging
-from typing import Dict, Optional, List, Union, Any
-from dotenv import load_dotenv
-from pathlib import Path
-
-# Imports for new Provider system
-from .llm_providers import get_provider, LLMProvider
-from .utils.json_parser import extract_and_parse_json
-
-# Cargar variables de entorno explícitamente desde el directorio del script
-env_path = Path(__file__).parent / '.env'
-load_dotenv(dotenv_path=env_path)
-
-logger = logging.getLogger(__name__)
+"""
+Generador de variaciones de ejercicios con mayor complejidad.
+Utiliza APIs de IA para generar variaciones inteligentes.
+"""
+import os
+import logging
+from typing import Dict, Optional, List, Union, Any
+from dotenv import load_dotenv
+from pathlib import Path
+
+# Imports for new Provider system
+from .llm_providers import get_provider, LLMProvider
+from .utils.json_parser import extract_and_parse_json
+
+# Cargar variables de entorno explícitamente desde el directorio del script
+env_path = Path(__file__).parent / '.env'
+load_dotenv(dotenv_path=env_path)
+
+logger = logging.getLogger(__name__)
 
 
 
@@ -37,36 +37,36 @@ class VariationGenerator:
         
         self._provider_instance = None
     
-    def _get_provider(self):
-        """
-        Lazy loader para el proveedor, permitiendo configuración tardía de props.
-
-        Returns:
-            Instancia de LLMProvider si la inicialización fue exitosa
-            None si hubo un error de configuración
-        """
-        if self._provider_instance:
-            return self._provider_instance
-
-        kwargs = {}
-        if self.model_name:
-            kwargs['model_name'] = self.model_name
-        elif self.local_model and self.api_provider == 'local':
-             kwargs['model_name'] = self.local_model
-
-        if self.base_url:
-            kwargs['base_url'] = self.base_url
-
-        try:
-            self._provider_instance = get_provider(self.api_provider, **kwargs)
-            logger.info(f"[VariationGenerator] Proveedor inicializado: {self.api_provider}")
-            return self._provider_instance
-        except ValueError as e:
-            logger.error(f"[VariationGenerator] Error inicializando proveedor '{self.api_provider}': {e}")
-            return None
-        except Exception as e:
-            logger.error(f"[VariationGenerator] Error inesperado inicializando proveedor '{self.api_provider}': {e}")
-            return None
+    def _get_provider(self):
+        """
+        Lazy loader para el proveedor, permitiendo configuración tardía de props.
+
+        Returns:
+            Instancia de LLMProvider si la inicialización fue exitosa
+            None si hubo un error de configuración
+        """
+        if self._provider_instance:
+            return self._provider_instance
+
+        kwargs = {}
+        if self.model_name:
+            kwargs['model_name'] = self.model_name
+        elif self.local_model and self.api_provider == 'local':
+             kwargs['model_name'] = self.local_model
+
+        if self.base_url:
+            kwargs['base_url'] = self.base_url
+
+        try:
+            self._provider_instance = get_provider(self.api_provider, **kwargs)
+            logger.info(f"[VariationGenerator] Proveedor inicializado: {self.api_provider}")
+            return self._provider_instance
+        except ValueError as e:
+            logger.error(f"[VariationGenerator] Error inicializando proveedor '{self.api_provider}': {e}")
+            return None
+        except Exception as e:
+            logger.error(f"[VariationGenerator] Error inesperado inicializando proveedor '{self.api_provider}': {e}")
+            return None
 
     def _create_prompt(self, exercise: Dict, analysis: Dict) -> str:
         """Crea el prompt para generar una variación."""
@@ -105,8 +105,8 @@ REGLAS DE FORMATO:
 Genera solo el contenido solicitado."""
         return prompt
 
-    def _create_quiz_prompt(self, context_info: Dict[str, Any]) -> str:
-        """Crea prompt para ejercicios de selección única."""
+    def _create_quiz_prompt(self, context_info: Dict[str, Any]) -> str:
+        """Crea prompt para ejercicios de selección única."""
         content = context_info.get('content', '')
         
         prompt = f"""Actúa como un profesor experto. Genera una pregunta de examen de tipo SELECCIÓN ÚNICA (Quiz) basada en el siguiente material:
@@ -133,33 +133,33 @@ REQUISITOS:
 """
         return prompt
 
-    def generate_variation(self, exercise: Dict[str, Any], analysis: Dict[str, Any], exercise_type: str = "development") -> Optional[Dict]:
-        """
-        Genera una variación de un ejercicio existente.
-        """
-         # 1. Crear prompt según tipo
-        if exercise_type == 'multiple_choice':
-            context_info = {
-                'content': f"Ejercicio Original:\n{exercise.get('content')}"
-            }
-            prompt = self._create_quiz_prompt(context_info)
-        else:
-            prompt = self._create_prompt(exercise, analysis)
-
-        # 2. Get Provider
-        provider = self._get_provider()
-        if not provider:
-            logger.warning("[VariationGenerator] Proveedor no inicializado, no se puede generar variación")
-            return None
-
-        # 3. Generar
-        content = provider.generate_content(prompt, system_prompt="Eres un experto en diseño de exámenes de ingeniería.")
-
-        if not content:
-            logger.warning("[VariationGenerator] Proveedor retornó contenido vacío")
-            return None
-
-        # 4. Parsear respuesta
+    def generate_variation(self, exercise: Dict[str, Any], analysis: Dict[str, Any], exercise_type: str = "development", max_tokens: int = 2000) -> Optional[Dict]:
+        """
+        Genera una variación de un ejercicio existente.
+        """
+         # 1. Crear prompt según tipo
+        if exercise_type == 'multiple_choice':
+            context_info = {
+                'content': f"Ejercicio Original:\n{exercise.get('content')}"
+            }
+            prompt = self._create_quiz_prompt(context_info)
+        else:
+            prompt = self._create_prompt(exercise, analysis)
+
+        # 2. Get Provider
+        provider = self._get_provider()
+        if not provider:
+            logger.warning("[VariationGenerator] Proveedor no inicializado, no se puede generar variación")
+            return None
+
+        # 3. Generar
+        content = provider.generate_content(prompt, system_prompt="Eres un experto en diseño de exámenes de ingeniería.", max_tokens=max_tokens)
+
+        if not content:
+            logger.warning("[VariationGenerator] Proveedor retornó contenido vacío")
+            return None
+
+        # 4. Parsear respuesta
         variation_content = ""
         variation_solution = ""
         
@@ -212,10 +212,10 @@ INSTRUCCIONES:
 """
         return prompt
 
-    def generate_new_exercise_from_topic(self, topic: str, tags: Optional[List[str]] = None, difficulty: str = "alta", exercise_type: str = "development") -> Optional[Dict]:
-        """
-        Genera un ejercicio nuevo desde cero.
-        """
+    def generate_new_exercise_from_topic(self, topic: str, tags: Optional[List[str]] = None, difficulty: str = "alta", exercise_type: str = "development", max_tokens: int = 2000) -> Optional[Dict]:
+        """
+        Genera un ejercicio nuevo desde cero.
+        """
         tags = tags or []
         context = {} # Base implementations doesn't use context
         
@@ -233,7 +233,7 @@ INSTRUCCIONES:
         if not provider: return None
         
         # 3. Generar
-        content = provider.generate_content(prompt)
+        content = provider.generate_content(prompt, max_tokens=max_tokens)
         if not content: return None
         
         # 4. Parsear
@@ -265,12 +265,12 @@ INSTRUCCIONES:
              'type': exercise_type
         }
 
-    def generate_variation_with_solution(self, exercise: Dict, analysis: Dict) -> Optional[Dict]:
+    def generate_variation_with_solution(self, exercise: Dict, analysis: Dict, max_tokens: int = 2000) -> Optional[Dict]:
         """
         Genera una variación con su solución.
         """
         # Primero generar el ejercicio
-        variation = self.generate_variation(exercise, analysis)
+        variation = self.generate_variation(exercise, analysis, max_tokens=max_tokens)
         
         if not variation:
             return None
@@ -290,7 +290,7 @@ EJERCICIO:
 
 GENERA LA SOLUCIÓN COMPLETA:"""
         
-        solution_content = provider.generate_content(solution_prompt)
+        solution_content = provider.generate_content(solution_prompt, max_tokens=max_tokens)
         
         if solution_content:
             variation['variation_solution'] = solution_content

{evolutia-0.1.3.dist-info → evolutia-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evolutia
-Version: 0.1.3
+Version: 0.1.5
 Summary: Sistema automatizado para generar preguntas de examen desafiantes basadas en materiales didácticos existentes
 Home-page: https://github.com/glacy/evolutIA
 Author: Gerardo Lacy-Mora

{evolutia-0.1.3.dist-info → evolutia-0.1.5.dist-info}/RECORD

@@ -1,17 +1,17 @@
-evolutia_cli.py,sha256=1_1JNf1YX465velp9U2-xFYOGTk-hGA-9SMug9Yr15M,8395
+evolutia_cli.py,sha256=-B9615kK6DjGB8RckVvG_o6S_88fE56_RFv4GcRHqx8,8522
 evolutia/__init__.py,sha256=Fne5WLrmdjIxOSSL6z92G2alAoGRzwGnvpejFqksTiY,350
 evolutia/async_llm_providers.py,sha256=HVbKmWhg9rGe3FphsLjeil0SD85tk83j8xtw3W5HjZU,5465
 evolutia/complexity_validator.py,sha256=4BtRvTDVfQUweaz-4QabO-wiEtr5S7_3n0AuAd1Bn5Y,7490
 evolutia/config_manager.py,sha256=Cf_MQzUq-g5rQuJN_csKt9gJSwPJ6kYg-Dw8uYp1um0,9183
-evolutia/evolutia_engine.py,sha256=PDpXPydffrQfT_VUX4BYyW2jqKFIUbO0QVQARk76Yp8,22351
+evolutia/evolutia_engine.py,sha256=-UPEOHydeZCjipmcqHpiJmcCFEiQYGDMO4rx3_KIO2c,22713
 evolutia/exam_generator.py,sha256=7CKdo86u8bC6yYJY7I3WITcyV_4L8lMRETngGYf2WbU,13837
 evolutia/exceptions.py,sha256=A1xnYmPlySYEeTHR12ct7Apet2n6JhGugjOYX4mmobw,779
 evolutia/exercise_analyzer.py,sha256=bY4c-hqeef_xrDTVC9X4MzZlglrhNejWtwEgI_NJ-Mw,8666
 evolutia/imports.py,sha256=CTsHJ5FukEKMh5GM_O9EsoH61F6xMGj_A3gV0H869Hc,5914
-evolutia/llm_providers.py,sha256=TMOVWv9kZcj5Ydp_nBvaJaEohjPdhHPmFPa-VHC2yJA,14955
+evolutia/llm_providers.py,sha256=y3g8n-VMRAn3X0JMt2Ky5h5UEqImXfvYCou7wiuU17c,15505
 evolutia/material_extractor.py,sha256=CQGgCS9sRBNIhKeR2ya4V7TYBz47yWcEQdjpGEduZRY,12429
 evolutia/retry_utils.py,sha256=j-DS7MtQaNq2i1Rp788mPVRa_-xs_pEM6PGMzXpICfw,9830
-evolutia/variation_generator.py,sha256=ucJL2_OE0fGZeke5BiXItT3vqYLGRo-L-U-i-sHX6Ts,11383
+evolutia/variation_generator.py,sha256=bmH17aeatQFYOqF5C2R9U2220imQhcvELSGAqPtEgr0,11629
 evolutia/cache/__init__.py,sha256=XAI2hwXc7SMrvs3n8VxgmbVuB7Ma4euQsqdoTuhPRQ0,263
 evolutia/cache/exercise_cache.py,sha256=eVd0DmcBxoq3eiuOCjiWAZUCtQNIdZBaO6qKqAQ9vjU,7010
 evolutia/cache/llm_cache.py,sha256=BdUcVeJ8GvAtIZ1s4rEgklcqaXPwORl8VoZp6tdzA_g,16608
@@ -22,16 +22,17 @@ evolutia/rag/enhanced_variation_generator.py,sha256=hFA60OW6-02d8HqluiDTgh7Apwkj
 evolutia/rag/rag_indexer.py,sha256=Rg-PtvEJXW5IGo-nLh3h1TT51YXnbz9mwoifUTwUiZM,16732
 evolutia/rag/rag_manager.py,sha256=ODfOiREv8OyQ7WfCdIOPmynJ6grckN6uLYjuECrt3LU,8071
 evolutia/rag/rag_retriever.py,sha256=It8gB-dL0Ip2r2zCD5Oq_Hmc-C8fbCyrCLaNOghqhLw,14370
+evolutia/schemas/config.schema.json,sha256=GzQxWpJeog5BMYlkEFkzzwk3UNVX0ndDyKRh6tvOafs,6481
 evolutia/utils/__init__.py,sha256=rD3hl92fM5L3_7QCRrCjyR91bx_bOsw0baVQrCjy6vg,56
 evolutia/utils/json_parser.py,sha256=71yA15bYCGkZ7pAhLoqoGuKTrFyAsjWDNEgG7rhsloo,3308
 evolutia/utils/markdown_parser.py,sha256=LjMFMuq4liXaRVXBd6FsH1ZlfiFlO8Hryg-CNAgaYYk,5743
 evolutia/utils/math_extractor.py,sha256=tKfzwnmj8Puw9w624bBAnRjgxr3my-O3a9UcIyi8XTk,5125
-evolutia/validation/__init__.py,sha256=q56nc4RekrPSuOAxJdogBMZHik8Lj69V2SyLD5DfRqg,40
+evolutia/validation/__init__.py,sha256=TxFTXvjfbDaD26gIDy3XE7SEGdzwMV-aocX-OMs_wxE,111
 evolutia/validation/args_validator.py,sha256=lhlQ5_swUBYTO_7MXUgTgtwd_JLCCEjvh4YxM7KbtkE,10051
 evolutia/validation/config_validator.py,sha256=ATTI0--zZIG85WzASU59M2nW-nZbNSxWOe82QJ1vIMQ,20968
-evolutia-0.1.3.dist-info/licenses/LICENSE,sha256=jyOI5zt59oNBGE33KX2L1py7ZwWKqVFNcgEePR6o6YA,11564
-evolutia-0.1.3.dist-info/METADATA,sha256=Vr_Zb7mokCyTSmcC-P0K25Zu0-NYWIqYcFMvBIsOT34,16955
-evolutia-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-evolutia-0.1.3.dist-info/entry_points.txt,sha256=BMYhya9XcbrfsjGfp4lMVQF0TK3Bd_Kj6mZtFhVJ7zo,47
-evolutia-0.1.3.dist-info/top_level.txt,sha256=GrIvEW8qAI8CIW5XTPnCqC7o06qJIL8p9CGwVhCEC4s,22
-evolutia-0.1.3.dist-info/RECORD,,
+evolutia-0.1.5.dist-info/licenses/LICENSE,sha256=jyOI5zt59oNBGE33KX2L1py7ZwWKqVFNcgEePR6o6YA,11564
+evolutia-0.1.5.dist-info/METADATA,sha256=VUgcMYe8hYZmGneid3GEjcveiijXnTW6zrvOWIxwYz8,16955
+evolutia-0.1.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+evolutia-0.1.5.dist-info/entry_points.txt,sha256=BMYhya9XcbrfsjGfp4lMVQF0TK3Bd_Kj6mZtFhVJ7zo,47
+evolutia-0.1.5.dist-info/top_level.txt,sha256=GrIvEW8qAI8CIW5XTPnCqC7o06qJIL8p9CGwVhCEC4s,22
+evolutia-0.1.5.dist-info/RECORD,,

evolutia_cli.py

@@ -12,12 +12,12 @@ from dotenv import load_dotenv
 # Cargar variables de entorno desde el directorio actual (donde el usuario ejecuta el comando)
 load_dotenv()
 
-# Add current directory to path so we can import 'evolutia' package if running locally without install
-sys.path.insert(0, str(Path(__file__).parent))
-
-from evolutia.evolutia_engine import EvolutiaEngine
-from evolutia.config_manager import ConfigManager
-from evolutia.validation.args_validator import ArgsValidator, ValidationError
+# Add current directory to path so we can import 'evolutia' package if running locally without install
+sys.path.insert(0, str(Path(__file__).parent))
+
+from evolutia.evolutia_engine import EvolutiaEngine
+from evolutia.config_manager import ConfigManager
+from evolutia.validation.args_validator import ArgsValidator, ValidationError
 
 # Configurar logging
 logging.basicConfig(
@@ -64,20 +64,21 @@ Ejemplos:
     parser.add_argument('--query', type=str, help='Consulta RAG')
     parser.add_argument('--workers', type=int, default=5, help='Número de hilos para generación paralela')
     parser.add_argument('--analyze', action='store_true', help='Analizar estructura y generar config.yaml')
+    parser.add_argument('--max_tokens', type=int, default=2000, help='Máximo de tokens para generación')
+
+    args = parser.parse_args()
+
+    # Validar argumentos con ArgsValidator
+    validator = ArgsValidator()
+    is_valid, errors = validator.validate_args(args)
+
+    if not is_valid:
+        logger.error("Errores de validación en argumentos:")
+        for error in errors:
+            logger.error(f"  - {error}")
+        parser.error("\n".join(errors))
 
-    args = parser.parse_args()
-
-    # Validar argumentos con ArgsValidator
-    validator = ArgsValidator()
-    is_valid, errors = validator.validate_args(args)
-
-    if not is_valid:
-        logger.error("Errores de validación en argumentos:")
-        for error in errors:
-            logger.error(f"  - {error}")
-        parser.error("\n".join(errors))
-
-    if args.analyze:
+    if args.analyze:
         print("Analizando estructura del proyecto...")
         ConfigManager(str(Path.cwd())).update_config_from_structure()
         return 0