Update app.py

app.py

@@ -32,7 +32,6 @@ class LLMManager:
         self.load_all_models()
 
     def load_all_models(self):
-        """Cargar todos los modelos en RAM"""
         for model_config in self.models_config:
             try:
                 model_name = model_config["name"]
@@ -81,7 +80,6 @@ class LLMManager:
                 }
 
     def _download_model(self, model_url):
-        """Descargar modelo"""
         temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".gguf")
         temp_path = temp_file.name
         temp_file.close()
@@ -101,11 +99,9 @@ class LLMManager:
         return temp_path
 
     def get_model(self, model_name):
-        """Obtener instancia de modelo por nombre"""
         return self.models.get(model_name)
 
     def chat_completion(self, model_name, messages, **kwargs):
-        """Generar respuesta con modelo específico"""
         if not self.generation_lock.acquire(blocking=False):
             return {"error": "Servidor ocupado - Generación en progreso"}
         
@@ -123,30 +119,12 @@ class LLMManager:
             
             def generate():
                 try:
-                    # Convertir parámetros de OpenAI a parámetros de llama.cpp
-                    llama_kwargs = kwargs.copy()
-                    
-                    # Mapear repetition_penalty a repeat_penalty
-                    if 'repetition_penalty' in llama_kwargs:
-                        llama_kwargs['repeat_penalty'] = llama_kwargs.pop('repetition_penalty')
-                    
-                    # presence_penalty y frequency_penalty no son soportados directamente por llama.cpp
-                    # Se mantienen en los kwargs pero no se pasan a la llamada
-                    # ya que llama.cpp solo acepta repeat_penalty
-                    
-                    # Filtrar solo los parámetros que acepta llama.cpp
-                    valid_params = [
-                        'temperature', 'top_p', 'top_k', 'max_tokens', 'stream',
-                        'stop', 'seed', 'repeat_penalty', 'frequency_penalty',
-                        'presence_penalty', 'repetition_penalty'  # Estos últimos para compatibilidad
-                    ]
-                    
-                    filtered_kwargs = {k: v for k, v in llama_kwargs.items() 
-                                     if k in valid_params and not (k in ['frequency_penalty', 'presence_penalty', 'repetition_penalty'] and k != 'repeat_penalty')}
+                    if 'repetition_penalty' in kwargs:
+                        kwargs['repeat_penalty'] = kwargs.pop('repetition_penalty')
                     
                     result[0] = model_data["instance"].create_chat_completion(
                         messages=messages,
-                        **filtered_kwargs
+                        **kwargs
                     )
                 except Exception as e:
                     exception[0] = e
@@ -170,7 +148,6 @@ class LLMManager:
             gc.collect()
     
     def get_loaded_models(self):
-        """Obtener lista de modelos cargados"""
         loaded = []
         for name, data in self.models.items():
             if data["loaded"]:
@@ -178,7 +155,6 @@ class LLMManager:
         return loaded
 
     def get_all_models_status(self):
-        """Obtener estado de todos los modelos"""
         status = {}
         for name, data in self.models.items():
             status[name] = {
@@ -189,7 +165,6 @@ class LLMManager:
                 status[name]["error"] = data["error"]
         return status
 
-# Inicializar el gestor con todos los modelos
 llm_manager = LLMManager(MODELS)
 
 @app.route('/')
@@ -235,9 +210,9 @@ def home():
             • top_k= (0-100)<br>
             • model= (nombre del modelo)<br>
             • max_tokens= (máximo tokens a generar, default: {MAX_GENERATION_TOKENS})<br>
-            • repetition_penalty= (penalización de repetición, 1.0-2.0)<br>
-            • presence_penalty= (penalización de presencia, -2.0 a 2.0)<br>
-            • frequency_penalty= (penalización de frecuencia, -2.0 a 2.0)
+            • repetition_penalty= (penalización de repetición)<br>
+            • presence_penalty= (penalización de presencia)<br>
+            • frequency_penalty= (penalización de frecuencia)
         </div>
         
         <div class="endpoint">
@@ -273,11 +248,9 @@ def chat_completions():
             if key not in ['messages', 'model']:
                 kwargs[key] = data[key]
         
-        # Aplicar límite de tokens si no se especifica
         if 'max_tokens' not in kwargs:
             kwargs['max_tokens'] = MAX_GENERATION_TOKENS
         else:
-            # Validar que max_tokens no exceda el máximo permitido
             if kwargs['max_tokens'] > MAX_GENERATION_TOKENS:
                 kwargs['max_tokens'] = MAX_GENERATION_TOKENS
         
@@ -293,9 +266,7 @@ def chat_completions():
 
 @app.route('/generate/<path:user_message>', methods=['GET'])
 def generate_endpoint(user_message):
-    """Endpoint GET para generar respuestas - Devuelve solo texto"""
     try:
-        # Obtener parámetros GET con valores por defecto
         system_instruction = request.args.get('system', '')
         temperature = float(request.args.get('temperature', 0.7))
         top_p = float(request.args.get('top_p', 0.95))
@@ -303,12 +274,10 @@ def generate_endpoint(user_message):
         model_name = request.args.get('model', MODELS[0]["name"])
         max_tokens = int(request.args.get('max_tokens', MAX_GENERATION_TOKENS))
         
-        # Nuevos parámetros para penalizaciones
         repetition_penalty = request.args.get('repetition_penalty')
         presence_penalty = request.args.get('presence_penalty')
         frequency_penalty = request.args.get('frequency_penalty')
         
-        # Validar rangos
         if not 0 <= temperature <= 2:
             return Response(
                 f"Error: El parámetro 'temperature' debe estar entre 0 y 2",
@@ -330,16 +299,9 @@ def generate_endpoint(user_message):
                 mimetype='text/plain'
             )
         
-        # Validar penalizaciones si están presentes
         if repetition_penalty:
             try:
                 repetition_penalty = float(repetition_penalty)
-                if not 1.0 <= repetition_penalty <= 2.0:
-                    return Response(
-                        f"Error: El parámetro 'repetition_penalty' debe estar entre 1.0 y 2.0",
-                        status=400,
-                        mimetype='text/plain'
-                    )
             except ValueError:
                 return Response(
                     "Error: repetition_penalty debe ser número válido",
@@ -350,12 +312,6 @@ def generate_endpoint(user_message):
         if presence_penalty:
             try:
                 presence_penalty = float(presence_penalty)
-                if not -2.0 <= presence_penalty <= 2.0:
-                    return Response(
-                        f"Error: El parámetro 'presence_penalty' debe estar entre -2.0 y 2.0",
-                        status=400,
-                        mimetype='text/plain'
-                    )
             except ValueError:
                 return Response(
                     "Error: presence_penalty debe ser número válido",
@@ -366,12 +322,6 @@ def generate_endpoint(user_message):
         if frequency_penalty:
             try:
                 frequency_penalty = float(frequency_penalty)
-                if not -2.0 <= frequency_penalty <= 2.0:
-                    return Response(
-                        f"Error: El parámetro 'frequency_penalty' debe estar entre -2.0 y 2.0",
-                        status=400,
-                        mimetype='text/plain'
-                    )
             except ValueError:
                 return Response(
                     "Error: frequency_penalty debe ser número válido",
@@ -379,11 +329,9 @@ def generate_endpoint(user_message):
                     mimetype='text/plain'
                 )
         
-        # Limitar max_tokens a la configuración máxima
         if max_tokens > MAX_GENERATION_TOKENS:
             max_tokens = MAX_GENERATION_TOKENS
         
-        # Validar que el modelo existe
         if model_name not in llm_manager.models:
             return Response(
                 f"Error: Modelo '{model_name}' no encontrado. Modelos disponibles: {', '.join(llm_manager.models.keys())}",
@@ -391,13 +339,11 @@ def generate_endpoint(user_message):
                 mimetype='text/plain'
             )
         
-        # Crear mensajes
         messages = [
             {"role": "system", "content": system_instruction},
             {"role": "user", "content": user_message}
         ]
         
-        # Configurar parámetros
         kwargs = {
             "temperature": temperature,
             "top_p": top_p,
@@ -408,7 +354,6 @@ def generate_endpoint(user_message):
         if top_k:
             kwargs["top_k"] = int(top_k)
         
-        # Añadir penalizaciones si están presentes
         if repetition_penalty:
             kwargs["repetition_penalty"] = repetition_penalty
         
@@ -418,7 +363,6 @@ def generate_endpoint(user_message):
         if frequency_penalty:
             kwargs["frequency_penalty"] = frequency_penalty
             
-        # Generar respuesta
         result = llm_manager.chat_completion(model_name, messages, **kwargs)
         
         if "error" in result:
@@ -433,7 +377,6 @@ def generate_endpoint(user_message):
         if not response_text:
             response_text = "No se generó respuesta"
         
-        # Devolver solo el texto plano
         return Response(
             response_text,
             status=200,
@@ -468,7 +411,6 @@ def health():
 
 @app.route('/models', methods=['GET'])
 def list_models():
-    """Endpoint para listar todos los modelos y su estado"""
     return jsonify({
         "available_models": MODELS,
         "status": llm_manager.get_all_models_status(),
@@ -480,7 +422,6 @@ def list_models():
 
 @app.route('/models/<model_name>', methods=['GET'])
 def get_model_status(model_name):
-    """Endpoint para obtener el estado de un modelo específico"""
     model_data = llm_manager.get_model(model_name)
     if not model_data:
         return jsonify({"error": f"Modelo '{model_name}' no encontrado"}), 404