Primer commit

llms/Modelos/Base_model.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+class ModeloABC(ABC):
+    """
+    Clase base para definir la interfaz de un modelo conversacional.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        temperature: float = 0.7,
+        top_p: float = 1.0,
+        top_k: int = None,
+        frecuencia_penalizacion: float = 0.0,
+        num_tokens_maximos: int = 512
+    ):
+        self.model = model
+        self.temperature = temperature
+        self.top_p = top_p
+        self.top_k = top_k
+        self.frecuencia_penalizacion = frecuencia_penalizacion
+        self.num_tokens_maximos = num_tokens_maximos
+
+    @abstractmethod
+    async def responder(self, prompt: str, system_prompt: str = "", **kwargs) -> str:
+        """
+        Devuelve una respuesta a partir de un prompt y configuración del modelo.
+        Este método debe implementarse de forma asíncrona en las subclases.
+        """
+        pass

llms/Modelos/Openai_model.py

@@ -0,0 +1,64 @@
+from llms.Modelos.Base_model import ModeloABC
+from backend.ConexionApis.OpenAi_conexion import OpenAICliente
+
+class ModeloOpenAI(ModeloABC):
+    def __init__(
+        self,
+        cliente: OpenAICliente,
+        model: str = "gpt-4o",
+        temperature: float = 0.7,
+        top_p: float = 1.0,
+        top_k: int = None,
+        frecuencia_penalizacion: float = 0.0,
+        num_tokens_maximos: int = 512,
+        use_legacy: bool = False
+    ):
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            frecuencia_penalizacion=frecuencia_penalizacion,
+            num_tokens_maximos=num_tokens_maximos
+        )
+        self.cliente = cliente
+        self.use_legacy = use_legacy
+
+    async def responder(self, prompt: str, system_prompt: str = "", **kwargs) -> str:
+        import asyncio
+
+        if self.use_legacy:
+            loop = asyncio.get_event_loop()
+            respuesta = await loop.run_in_executor(
+                None,
+                lambda: self.cliente.completion(
+                    model=self.model,
+                    prompt=prompt,
+                    temperature=self.temperature,
+                    top_p=self.top_p,
+                    max_tokens=self.num_tokens_maximos,
+                    frequency_penalty=self.frecuencia_penalizacion,
+                    **kwargs
+                )
+            )
+            return respuesta.choices[0].text.strip()
+        else:
+            messages = []
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            messages.append({"role": "user", "content": prompt})
+
+            loop = asyncio.get_event_loop()
+            respuesta = await loop.run_in_executor(
+                None,
+                lambda: self.cliente.chat_completion(
+                    model=self.model,
+                    messages=messages,
+                    temperature=self.temperature,
+                    top_p=self.top_p,
+                    max_tokens=self.num_tokens_maximos,
+                    frequency_penalty=self.frecuencia_penalizacion,
+                    **kwargs
+                )
+            )
+            return respuesta.choices[0].message.content

llms/Modelos/Openai_model_mmr.py

@@ -0,0 +1,86 @@
+import os
+from dotenv import load_dotenv
+from sqlalchemy import Column, Integer, String, Float, Boolean
+
+from backend.ConexionSql.Base_conexion import ConexionBase
+from backend.base import Base
+from llms.Modelos.Openai_model import ModeloOpenAI  # Clase real de lógica
+
+# ----------------------
+# Cargar clave maestra
+# ----------------------
+from entrypoint import ENV_PATH
+load_dotenv(ENV_PATH)
+pssword = os.getenv('MASTER_PASSWORD')
+if pssword is None:
+    raise ValueError("MASTER_PASSWORD no está definida en el archivo .env")
+
+# ----------------------
+# MODELO (SQLAlchemy)
+# ----------------------
+
+class ModeloOpenAIConfigModel(Base):
+    __tablename__ = 'modelo_openai_configs'
+
+    id = Column(Integer, primary_key=True)
+    model = Column(String, nullable=False)
+    temperature = Column(Float, default=0.7)
+    top_p = Column(Float, default=1.0)
+    top_k = Column(Integer, nullable=True)
+    frecuencia_penalizacion = Column(Float, default=0.0)
+    num_tokens_maximos = Column(Integer, default=512)
+    use_legacy = Column(Boolean, default=False)
+
+# ----------------------
+# MAPPER
+# ----------------------
+
+class ModeloOpenAIConfigMapper:
+    @staticmethod
+    def to_dict(obj: ModeloOpenAI) -> dict:
+        return {
+            "model": obj.model,
+            "temperature": obj.temperature,
+            "top_p": obj.top_p,
+            "top_k": obj.top_k,
+            "frecuencia_penalizacion": obj.frecuencia_penalizacion,
+            "num_tokens_maximos": obj.num_tokens_maximos,
+            "use_legacy": obj.use_legacy
+        }
+
+    @staticmethod
+    def from_model(model: ModeloOpenAIConfigModel, cliente: object) -> ModeloOpenAI:
+        return ModeloOpenAI(
+            cliente=cliente,
+            model=model.model,
+            temperature=model.temperature,
+            top_p=model.top_p,
+            top_k=model.top_k,
+            frecuencia_penalizacion=model.frecuencia_penalizacion,
+            num_tokens_maximos=model.num_tokens_maximos,
+            use_legacy=model.use_legacy
+        )
+
+# ----------------------
+# REPO
+# ----------------------
+
+class ModeloOpenAIConfigRepo:
+    def __init__(self, conexion: ConexionBase, cliente: object):
+        self.session = conexion.get_session()
+        self.cliente = cliente  # Necesario para crear ModeloOpenAI
+
+    def add(self, config: ModeloOpenAI) -> int:
+        data = ModeloOpenAIConfigMapper.to_dict(config)
+        model = ModeloOpenAIConfigModel(**data)
+        self.session.add(model)
+        self.session.commit()
+        return model.id
+
+    def get_by_id(self, id_: int) -> ModeloOpenAI | None:
+        model = self.session.get(ModeloOpenAIConfigModel, id_)
+        return ModeloOpenAIConfigMapper.from_model(model, self.cliente) if model else None
+
+    def get_all(self) -> list[ModeloOpenAI]:
+        models = self.session.query(ModeloOpenAIConfigModel).all()
+        return [ModeloOpenAIConfigMapper.from_model(m, self.cliente) for m in models]