Create app.py

app.py

@@ -0,0 +1,153 @@
+import os
+from llama_cpp import Llama
+from transformers import AutoTokenizer, AutoModel
+import torch
+from pypdf import PdfReader
+import chromadb
+import gradio as gr
+
+# --- Configuración ---
+MODEL_PATH = "TheBloke/Llama-2-7B-Chat-GGML"  # Modelo de Hugging Face (se descargará si no existe localmente)
+MODEL_FILENAME = "llama-2-7b-chat.ggmlv3.q4_0.bin" # Nombre del archivo GGML dentro del repo
+KNOWLEDGE_BASE_PATH = "conocimiento"
+EMBEDDING_MODEL = "sentence-transformers/all-mpnet-base-v2"
+VECTOR_STORE_NAME = "mi_base_de_conocimiento"
+
+# --- Funciones de Carga y Procesamiento de Conocimiento ---
+def cargar_documentos(ruta_carpeta):
+    textos = []
+    for filename in os.listdir(ruta_carpeta):
+        if filename.endswith(".pdf"):
+            filepath = os.path.join(ruta_carpeta, filename)
+            with open(filepath, 'rb') as pdf_file:
+                pdf_reader = PdfReader(pdf_file)
+                for page in pdf_reader.pages:
+                    textos.append(page.extract_text())
+    return textos
+
+def dividir_en_fragmentos(textos, chunk_size=500, chunk_overlap=50):
+    fragmentos = []
+    for texto in textos:
+        for i in range(0, len(texto), chunk_size - chunk_overlap):
+            chunk = texto[i:i + chunk_size]
+            if len(chunk.strip()) > 0:
+                fragmentos.append(chunk)
+    return fragmentos
+
+# --- Función para Generar Embeddings ---
+def cargar_modelo_embeddings():
+    tokenizer = AutoTokenizer.from_pretrained(EMBEDDING_MODEL)
+    model = AutoModel.from_pretrained(EMBEDDING_MODEL)
+    return tokenizer, model
+
+def generar_embedding(texto, tokenizer, model):
+    inputs = tokenizer(texto, padding=True, truncation=True, return_tensors='pt')
+    with torch.no_grad():
+        outputs = model(**inputs)
+    return outputs.pooler_output.squeeze().numpy()
+
+# --- Funciones del Vector Store ---
+def crear_vector_store(fragmentos, tokenizer, embedding_model, nombre_coleccion):
+    client = chromadb.Client()
+    collection = client.get_or_create_collection(nombre_coleccion)
+    embeddings = [generar_embedding(f, tokenizer, embedding_model) for f in fragmentos]
+    collection.add(
+        embeddings=embeddings,
+        documents=fragmentos,
+        ids=[f"frag_{i}" for i in range(len(fragmentos))]
+    )
+    return collection
+
+def buscar_en_conocimiento(pregunta, collection, tokenizer, embedding_model, top_n=3):
+    embedding_pregunta = generar_embedding(pregunta, tokenizer, embedding_model)
+    resultados = collection.query(
+        query_embeddings=[embedding_pregunta],
+        n_results=top_n
+    )
+    return resultados['documents'][0] if resultados and resultados['documents'] else []
+
+# --- Carga del Modelo LLM ---
+def cargar_modelo_llm():
+    # Intenta descargar el modelo si no existe localmente
+    model_path_local = os.path.join("./modelo", MODEL_FILENAME)
+    if not os.path.exists("./modelo"):
+        os.makedirs("./modelo", exist_ok=True)
+    if not os.path.exists(model_path_local):
+        from huggingface_hub import hf_hub_download
+        print(f"Descargando modelo desde Hugging Face Hub: {MODEL_PATH}")
+        try:
+            hf_hub_download(repo_id=MODEL_PATH, filename=MODEL_FILENAME, local_dir="./modelo")
+            print(f"Modelo descargado exitosamente en: {model_path_local}")
+        except Exception as e:
+            print(f"Error al descargar el modelo: {e}")
+            return None
+    try:
+        llm = Llama(model_path=model_path_local)
+        return llm
+    except Exception as e:
+        print(f"Error al cargar el modelo LLM: {e}")
+        return None
+
+# --- Función Principal del Chatbot ---
+def chatbot(pregunta, historial=[]):
+    global llm_instance, vector_store, embedding_tokenizer, embedding_model
+
+    if llm_instance is None or vector_store is None or embedding_tokenizer is None or embedding_model is None:
+        return "Cargando recursos. Por favor, espera...", historial  # Indica que aún se está cargando
+
+    contexto = buscar_en_conocimiento(pregunta, vector_store, embedding_tokenizer, embedding_model)
+    historial_str = "\n".join([f"{msg['usuario']}: {msg['contenido']}\n{msg['bot']}: {msg['contenido']}" for msg in historial])
+
+    prompt = f"Basado en la siguiente información: '{contexto}' y la conversación anterior: '{historial_str}', responde a la pregunta: '{pregunta}'"
+
+    try:
+        output = llm_instance(
+            prompt,
+            max_tokens=256,
+            temperature=0.7,
+            stop=["</s>"],
+            echo=False
+        )
+        respuesta = output['choices'][0]['text'].strip()
+    except Exception as e:
+        respuesta = f"Error al generar la respuesta: {e}"
+
+    historial.append({"usuario": "Usuario", "contenido": pregunta})
+    historial.append({"bot": "Agente", "contenido": respuesta})
+    return respuesta, historial
+
+# --- Inicialización Global ---
+llm_instance = None
+vector_store = None
+embedding_tokenizer = None
+embedding_model = None
+
+def inicializar():
+    global llm_instance, vector_store, embedding_tokenizer, embedding_model
+    print("Inicializando recursos...")
+    llm_instance = cargar_modelo_llm()
+    if llm_instance:
+        print("Modelo LLM cargado.")
+        textos_pdf = cargar_documentos(KNOWLEDGE_BASE_PATH)
+        fragmentos = dividir_en_fragmentos(textos_pdf)
+        embedding_tokenizer, embedding_model = cargar_modelo_embeddings()
+        print("Modelo de embeddings cargado.")
+        vector_store = crear_vector_store(fragmentos, embedding_tokenizer, embedding_model, VECTOR_STORE_NAME)
+        print("Base de conocimientos vectorizada.")
+    else:
+        print("Error al inicializar el modelo LLM. La aplicación no funcionará correctamente.")
+
+# --- Interfaz de Gradio ---
+if __name__ == "__main__":
+    inicializar()
+
+    if llm_instance and vector_store and embedding_tokenizer and embedding_model:
+        interface = gr.ChatInterface(
+            fn=chatbot,
+            title="Chatbot con Base de Conocimiento",
+            description="Pregúntame cualquier cosa basada en los documentos PDF cargados.",
+            examples=["¿De qué trata el documento principal?", "¿Cuál es la idea clave del segundo archivo?"]
+        )
+        interface.launch()
+    else:
+        print("No se pudieron cargar todos los recursos necesarios. La interfaz de Gradio no se iniciará.")