Update app.py

app.py

@@ -1,128 +1,161 @@
-from fastapi import FastAPI
-from langchain_community.llms import VLLM
+from flask import Flask, request, jsonify, render_template_string
+from vllm import LLM, SamplingParams
 from langchain_community.cache import GPTCache
-import torch
-from langchain.chains.llm import LLMChain
-from transformers import pipeline
-import uvicorn
-import threading
-import time
-import nltk
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-import psutil
-import os
-import gc
-import logging
-
-logging.basicConfig(level=logging.INFO)
-nltk.download('punkt')
-nltk.download('stopwords')
-
-app = FastAPI()
-
-device = torch.device("cpu")
 
+app = Flask(__name__)
+
+Configuración de los modelos de lenguaje
 modelos = {
-    "gpt2-medium": VLLM(model="gpt2-medium", device=device),
-    "qwen2.5-0.5b": VLLM(model="Qwen/Qwen2.5-0.5B-Instruct", device=device),
-    "llamaxd": VLLM(model="Hjgugugjhuhjggg/llama-3.2-1B-spinquant-hf", device=device)
+    "facebook/opt-125m": LLM(model="facebook/opt-125m"),
+    "llama-3.2-1B": LLM(model="Hjgugugjhuhjggg/llama-3.2-1B-spinquant-hf"),
+    "gpt2": LLM(model="gpt2")
 }
 
+Configuración de los caches
 caches = {
     nombre: GPTCache(modelo, max_size=1000) 
     for nombre, modelo in modelos.items()
 }
 
-cadenas = {
-    nombre: LLMChain(modelo, caché) 
-    for nombre, modelo, caché in zip(modelos.keys(), modelos.values(), caches.values())
-}
-
-summarizer = pipeline("summarization", device=device)
-vectorizer = TfidfVectorizer()
-
-def keep_alive():
-    while True:
-        for cadena in cadenas.values():
-            try:
-                cadena.ask("¿Cuál es el sentido de la vida?")
-            except Exception as e:
-                logging.error(f"Error en modelo {cadena}: {e}")
-                cadenas.pop(cadena)
-        time.sleep(300)
-
-def liberar_recursos():
-    while True:
-        memoria_ram = psutil.virtual_memory().available / (1024.0 ** 3)
-        espacio_disco = psutil.disk_usage('/').free / (1024.0 ** 3)
-        if memoria_ram < 5 or espacio_disco < 5:
-            gc.collect()
-            for proc in psutil.process_iter(['pid', 'name']):
-                if proc.info['name'] == 'python':
-                    os.kill(proc.info['pid'], 9)
-        time.sleep(60)
-
-threading.Thread(target=keep_alive, daemon=True).start()
-threading.Thread(target=liberar_recursos, daemon=True).start()
-
-@app.post("/pregunta")
-async def pregunta(pregunta: str, modelo: str):
-    try:
-        respuesta = cadenas[modelo].ask(pregunta)
-        if len(respuesta.split()) > 2048:
-            mensajes = []
-            palabras = respuesta.split()
-            mensaje_actual = ""
-            for palabra in palabras:
-                if len(mensaje_actual.split()) + len(palabra.split()) > 2048:
-                    mensajes.append(mensaje_actual)
-                    mensaje_actual = palabra
-                else:
-                    mensaje_actual += " " + palabra
-            mensajes.append(mensaje_actual)
-            return {"respuestas": mensajes}
-        else:
-            resumen = summarizer(respuesta, max_length=50, min_length=5, do_sample=False)
-            pregunta_vec = vectorizer.fit_transform([pregunta])
-            respuesta_vec = vectorizer.transform([respuesta])
-            similitud = cosine_similarity(pregunta_vec, respuesta_vec)
-            return {
-                "respuesta": respuesta, 
-                "resumen": resumen[0]["summary_text"], 
-                "similitud": similitud[0][0]
-            }
-    except Exception as e:
-        logging.error(f"Error en modelo {modelo}: {e}")
-        return {"error": f"Modelo {modelo} no disponible"}
-
-@app.post("/resumen")
-async def resumen(texto: str):
-    try:
-        resumen = summarizer(texto, max_length=50, min_length=5, do_sample=False)
-        return {"resumen": resumen[0]["summary_text"]}
-    except Exception as e:
-        logging.error(f"Error en resumen: {e}")
-        return {"error": "Error en resumen"}
-
-@app.post("/similitud")
-async def similitud(texto1: str, texto2: str):
-    try:
-        texto1_vec = vectorizer.fit_transform([texto1])
-        texto2_vec = vectorizer.transform([texto2])
-        similitud = cosine_similarity(texto1_vec, texto2_vec)
-        return {"similitud": similitud[0][0]}
-    except Exception as e:
-        logging.error(f"Error en similitud: {e}")
-        return {"error": "Error en similitud"}
-
-@app.get("/modelos")
-async def modelos():
-    return {"modelos": list(cadenas.keys())}
-
-@app.get("/estado")
-async def estado():
-    return {"estado": "activo"}
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+Configuración de muestreo
+sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
+
+html_code_docs = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Documentación de la API</title>
+</head>
+<body>
+    <h1>API de Generación de Texto</h1>
+    <h2>Endpoints</h2>
+    <ul>
+        <li>
+            <h3>Generar texto</h3>
+            <p>Método: POST</p>
+            <p>Ruta: /generate</p>
+            <p>Parámetros:</p>
+            <ul>
+                <li>prompts: Lista de prompts para generar texto</li>
+                <li>modelo: Nombre del modelo a utilizar</li>
+            </ul>
+            <p>Ejemplo:</p>
+            <pre>curl -X POST -H "Content-Type: application/json" -d '{"prompts": ["Hola, cómo estás?"], "modelo": "facebook/opt-125m"}' http://localhost:5000/generate</pre>
+        </li>
+        <li>
+            <h3>Obtener lista de modelos</h3>
+            <p>Método: GET</p>
+            <p>Ruta: /modelos</p>
+            <p>Ejemplo:</p>
+            <pre>curl -X GET http://localhost:5000/modelos</pre>
+        </li>
+        <li>
+            <h3>Chatbot</h3>
+            <p>Método: POST</p>
+            <p>Ruta: /chatbot</p>
+            <p>Parámetros:</p>
+            <ul>
+                <li>mensaje: Mensaje para el chatbot</li>
+                <li>modelo: Nombre del modelo a utilizar</li>
+            </ul>
+            <p>Ejemplo:</p>
+            <pre>curl -X POST -H "Content-Type: application/json" -d '{"mensaje": "Hola, cómo estás?", "modelo": "facebook/opt-125m"}' http://localhost:5000/chatbot</pre>
+        </li>
+    </ul>
+</body>
+</html>
+"""
+
+html_code_chatbot = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Chatbot</title>
+</head>
+<body>
+    <h1>Chatbot</h1>
+    <form id="chat-form">
+        <input type="text" id="mensaje" placeholder="Escribe un mensaje">
+        <button type="submit">Enviar</button>
+    </form>
+    <div id="respuestas"></div>
+
+    <script>
+        const form = document.getElementById('chat-form');
+        const mensajeInput = document.getElementById('mensaje');
+        const respuestasDiv = document.getElementById('respuestas');
+
+        form.addEventListener('submit', (e) => {
+            e.preventDefault();
+            const mensaje = mensajeInput.value;
+            fetch('/chatbot', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ mensaje })
+            })
+            .then((res) => res.json())
+            .then((data) => {
+                const respuesta = data.respuesta;
+                const respuestaHTML = `<p>Tú: ${mensaje}</p><p>Chatbot: ${respuesta}</p>`;
+                respuestasDiv.innerHTML += respuestaHTML;
+                mensajeInput.value = '';
+            });
+        });
+    </script>
+</body>
+</html>
+"""
+
+@app.route('/generate', methods=['POST'])
+def generate():
+    data = request.get_json()
+    prompts = data.get('prompts', [])
+    modelo_seleccionado = data.get('modelo', "facebook/opt-125m")
+
+    if modelo_seleccionado not in modelos:
+        return jsonify({"error": "Modelo no encontrado"}), 404
+
+    outputs = caches[modelo_seleccionado].generate(prompts, sampling_params)
+
+    results = []
+    for output in outputs:
+        prompt = output.prompt
+        generated_text = output.outputs[0].text
+        results.append({
+            'prompt': prompt,
+            'generated_text': generated_text
+        })
+
+    return jsonify(results)
+
+@app.route('/modelos', methods=['GET'])
+def get_modelos():
+    return jsonify({"modelos": list(modelos.keys())})
+
+@app.route('/docs', methods=['GET'])
+def docs():
+    return render_template_string(html_code_docs)
+
+@app.route('/chatbot', methods=['POST'])
+def chatbot():
+    data = request.get_json()
+    mensaje = data.get('mensaje', '')
+    modelo_seleccionado = data.get('modelo', "facebook/opt-125m")
+
+    if modelo_seleccionado not in modelos:
+        return jsonify({"error": "Modelo no encontrado"}), 404
+
+    outputs = caches[modelo_seleccionado].generate([mensaje], sampling_params)
+
+    respuesta = outputs[0].outputs[0].text
+
+    return jsonify({"respuesta": respuesta})
+
+@app.route('/chat', methods=['GET'])
+def chat():
+    return render_template_string(html_code_chatbot)
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)