Update app.py

app.py

@@ -13,7 +13,7 @@ from concurrent.futures import ThreadPoolExecutor
 app = Flask(__name__)
 logging.basicConfig(level=logging.INFO)
 
-MAX_CONTEXT_TOKENS = 1024 * 10
+MAX_CONTEXT_TOKENS = 1024 * 4
 MAX_GENERATION_TOKENS = 1024 * 4
 
 with open('engines.json', 'r') as f:
@@ -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,6 +119,9 @@ class LLMManager:
             
             def generate():
                 try:
+                    if 'repetition_penalty' in kwargs:
+                        kwargs['repeat_penalty'] = kwargs.pop('repetition_penalty')
+                    
                     result[0] = model_data["instance"].create_chat_completion(
                         messages=messages,
                         **kwargs
@@ -149,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"]:
@@ -157,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] = {
@@ -168,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('/')
@@ -213,7 +209,10 @@ def home():
             • top_p= (0.0-1.0)<br>
             • top_k= (0-100)<br>
             • model= (nombre del modelo)<br>
-            • max_tokens= (máximo tokens a generar, default: {MAX_GENERATION_TOKENS})
+            • max_tokens= (máximo tokens a generar, default: {MAX_GENERATION_TOKENS})<br>
+            • 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">
@@ -249,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
         
@@ -269,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))
@@ -279,7 +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))
         
-        # Validar rangos
+        repetition_penalty = request.args.get('repetition_penalty')
+        presence_penalty = request.args.get('presence_penalty')
+        frequency_penalty = request.args.get('frequency_penalty')
+        
         if not 0 <= temperature <= 2:
             return Response(
                 f"Error: El parámetro 'temperature' debe estar entre 0 y 2",
@@ -301,11 +299,39 @@ def generate_endpoint(user_message):
                 mimetype='text/plain'
             )
         
-        # Limitar max_tokens a la configuración máxima
+        if repetition_penalty:
+            try:
+                repetition_penalty = float(repetition_penalty)
+            except ValueError:
+                return Response(
+                    "Error: repetition_penalty debe ser número válido",
+                    status=400,
+                    mimetype='text/plain'
+                )
+        
+        if presence_penalty:
+            try:
+                presence_penalty = float(presence_penalty)
+            except ValueError:
+                return Response(
+                    "Error: presence_penalty debe ser número válido",
+                    status=400,
+                    mimetype='text/plain'
+                )
+        
+        if frequency_penalty:
+            try:
+                frequency_penalty = float(frequency_penalty)
+            except ValueError:
+                return Response(
+                    "Error: frequency_penalty debe ser número válido",
+                    status=400,
+                    mimetype='text/plain'
+                )
+        
         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())}",
@@ -313,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,
@@ -328,12 +352,17 @@ def generate_endpoint(user_message):
         }
 
         if top_k:
-            try:
-                kwargs["top_k"] = int(top_k)
-            except ValueError:
-                return Response("Error: top_k debe ser número entero", status=400)
+            kwargs["top_k"] = int(top_k)
+        
+        if repetition_penalty:
+            kwargs["repetition_penalty"] = repetition_penalty
+        
+        if presence_penalty:
+            kwargs["presence_penalty"] = presence_penalty
+            
+        if frequency_penalty:
+            kwargs["frequency_penalty"] = frequency_penalty
             
-        # Generar respuesta
         result = llm_manager.chat_completion(model_name, messages, **kwargs)
         
         if "error" in result:
@@ -348,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,
@@ -383,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(),
@@ -395,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