Primera fase: se construyen las funciones para las primeras 12 preguntas

llm/context.py

@@ -0,0 +1,110 @@
+"""
+Módulo que implementa el contexto del patrón Strategy para modelos de lenguaje.
+
+Este módulo contiene la clase LLMContext que mantiene una referencia a la
+estrategia actual y delega en ella la creación del modelo de lenguaje.
+"""
+
+from typing import Dict, Any, Optional
+from .strategies import (
+    LLMStrategy,
+    OpenAIO4MiniStrategy,
+    OpenAIGPT41MiniStrategy,
+    AnthropicHaikuStrategy,
+    AnthropicSonnet37Strategy,
+    AnthropicHaiku45Strategy,
+)
+from .config import LLMConfig
+
+
+class LLMContext:
+    """
+    Contexto que utiliza diferentes estrategias para crear modelos de lenguaje.
+
+    Esta clase es el punto central de interacción con el sistema de modelos.
+    Mantiene una referencia a la estrategia actual y delega la creación
+    del modelo a dicha estrategia.
+    """
+
+    def __init__(self):
+        """
+        Inicializa el contexto con las estrategias disponibles.
+        """
+        # Mapeo de proveedores y modelos a estrategias
+        self._strategies = {
+            "openai": {
+                "o4-mini": OpenAIO4MiniStrategy(),
+                "gpt-4.1-mini": OpenAIGPT41MiniStrategy(),
+            },
+            "anthropic": {
+                "claude-3-5-haiku-20241022": AnthropicHaikuStrategy(),
+                "claude-sonnet-4-5": AnthropicSonnet37Strategy(),
+                "claude-haiku-4-5": AnthropicHaiku45Strategy(),
+            },
+        }
+        self._current_strategy: Optional[LLMStrategy] = None
+        self._config: Optional[Dict[str, Any]] = None
+
+    def set_strategy(self, config: LLMConfig) -> None:
+        """
+        Establece la estrategia actual basada en la configuración.
+
+        Args:
+            config: Configuración del modelo
+
+        Raises:
+            ValueError: Si el proveedor o modelo no están soportados
+        """
+        provider = config.provider.lower()
+
+        # Verificar que el proveedor es válido
+        if provider not in self._strategies:
+            raise ValueError(f"Proveedor no soportado: {provider}")
+
+        # Si se especificó un modelo, usarlo
+        if config.model_name:
+            model_name = config.model_name
+            if model_name not in self._strategies[provider]:
+                raise ValueError(f"Modelo no soportado para {provider}: {model_name}")
+            self._current_strategy = self._strategies[provider][model_name]
+        else:
+            # Si no se especificó un modelo, usar el primero disponible
+            self._current_strategy = next(iter(self._strategies[provider].values()))
+
+        # Guardar la configuración
+        self._config = config.as_dict()
+
+    def get_llm(self):
+        """
+        Crea y devuelve un modelo de lenguaje usando la estrategia actual.
+
+        Returns:
+            Instancia del modelo de lenguaje
+
+        Raises:
+            ValueError: Si no se ha establecido una estrategia
+        """
+        if not self._current_strategy:
+            raise ValueError("No se ha establecido una estrategia")
+
+        return self._current_strategy.create_llm(self._config)
+
+    def register_strategy(
+        self, provider: str, model_name: str, strategy: LLMStrategy
+    ) -> None:
+        """
+        Registra una nueva estrategia.
+
+        Args:
+            provider: Nombre del proveedor (openai, anthropic)
+            model_name: Nombre del modelo
+            strategy: Instancia de la estrategia a registrar
+        """
+        provider = provider.lower()
+
+        # Crear el diccionario del proveedor si no existe
+        if provider not in self._strategies:
+            self._strategies[provider] = {}
+
+        # Registrar la estrategia
+        self._strategies[provider][model_name] = strategy