gnosticdev_chatbot

Running

App Files Files Community

gnosticdev commited on Feb 10

Commit

4716ee8

verified ·

1 Parent(s): 344bc83

Update app.py

Browse files

Files changed (1) hide show

app.py +107 -125

app.py CHANGED Viewed

@@ -1,127 +1,109 @@
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-# Verificar si hay GPU disponible (Zero-GPU)
-if torch.cuda.is_available():
-    device = "cuda"  # Usar GPU Zero
-    print("Zero-GPU detectada. Usando GPU para acelerar la inferencia.")
-else:
-    device = "cpu"  # Usar CPU si no hay GPU
-    print("No se detectó GPU. Usando CPU.")
-# Cargar modelo más pequeño para generar código
-model_name = "Qwen/Qwen2.5-Coder-1.5B-Instruct"
-print("Cargando modelo...")
-model = AutoModelForCausalLM.from_pretrained(
-    model_name,
-    torch_dtype=torch.float16,  # Usar float16 para ahorrar memoria
-    device_map="auto" if device == "cuda" else None  # Distribuir automáticamente en GPU si está disponible
 )
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-# Mover el modelo explícitamente a GPU si es necesario
-if device == "cuda":
-    model.to("cuda")
-print("Modelo cargado con éxito.")
-def generate_code(prompt):
-    """Genera código basado en el prompt del usuario."""
-    messages = [
-        {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
-        {"role": "user", "content": prompt},
-        {"role": "assistant", "content": ""}
-    ]
-    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    model_inputs = tokenizer([text], return_tensors="pt").to(device)  # Mover entradas al dispositivo correspondiente
-    generated_ids = model.generate(
-        **model_inputs,
-        max_new_tokens=128,  # Reducir tokens para respuestas más rápidas y ahorrar memoria
-        do_sample=True,
-        temperature=0.7
-    )
-    response = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
-    return response
-def extract_code(output):
-    """Extrae HTML, CSS y JavaScript del texto generado."""
-    html_code = ""
-    css_code = ""
-    js_code = ""
-    if "<style>" in output:
-        css_start = output.find("<style>") + len("<style>")
-        css_end = output.find("</style>")
-        css_code = output[css_start:css_end].strip()
-    if "<script>" in output:
-        js_start = output.find("<script>") + len("<script>")
-        js_end = output.find("</script>")
-        js_code = output[js_start:js_end].strip()
-    if "<body>" in output:
-        html_start = output.find("<body>") + len("<body>")
-        html_end = output.find("</body>")
-        html_code = output[html_start:html_end].strip()
-    return html_code, css_code, js_code
-def preview_app(html_code, css_code, js_code):
-    """Devuelve una vista previa interactiva de la aplicación."""
-    html_content = f"""
-    <html>
-        <head>
-            <style>
-                {css_code}
-            </style>
-        </head>
-        <body>
-            {html_code}
-            <script>
-                {js_code}
-            </script>
-        </body>
-    </html>
-    """
-    return html_content
-def run_chatbot(user_input):
-    """Procesa la entrada del usuario y genera código + previsualización."""
-    code_output = generate_code(user_input)
-    # Extraer HTML, CSS y JS del código generado
-    html_code, css_code, js_code = extract_code(code_output)
-    # Previsualizar la aplicación
-    preview = preview_app(html_code, css_code, js_code)
-    return (
-        f"### HTML:\n\n```html\n{html_code}\n```",
-        f"### CSS:\n\n```css\n{css_code}\n```",
-        f"### JavaScript:\n\n```javascript\n{js_code}\n```",
-        preview
-    )
-# Crear la interfaz con Gradio
-with gr.Blocks() as demo:
-    gr.Markdown("# Chatbot Creador de Aplicaciones")
-    with gr.Row():
-        with gr.Column():
-            user_input = gr.Textbox(label="Descripción de la aplicación (Ejemplo: 'Haz un botón rojo')", lines=3)
-            generate_button = gr.Button("Generar Código")
-        with gr.Column():
-            html_output = gr.Code(label="Código HTML", language="html")
-            css_output = gr.Code(label="Código CSS", language="css")
-            js_output = gr.Code(label="Código JavaScript", language="javascript")
-            preview_output = gr.HTML(label="Previsualización")
-    generate_button.click(
-        run_chatbot,
-        inputs=[user_input],
-        outputs=[html_output, css_output, js_output, preview_output]
-    )
-# Lanzar la aplicación
-if __name__ == "__main__":
-    demo.launch()

+import pandas as pd
+from langchain_groq import ChatGroq
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
 import gradio as gr
+# Carga los datos de entrenamiento
+df = pd.read_csv('./botreformasconstrucciones.csv')
+# Crea un arreglo con los contextos
+context_data = []
+for i in range(len(df)):
+  context = ""
+  for j in range(3):
+    context += df.columns[j]
+    context += ": "
+    context += df.iloc[i, j]  # Cambia esto
+    context += " "
+  context_data.append(context)
+# Importa las bibliotecas necesarias
+import os
+from langchain_groq import ChatGroq
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+# Obtiene la clave de API de Groq
+groq_key = os.environ.get('groq_api_keys')
+# Crea un objeto ChatGroq con el modelo de lenguaje
+llm = ChatGroq(model="llama-3.3-70b-versatile", api_key=groq_key)
+# Crea un objeto HuggingFaceEmbeddings con el modelo de embeddings
+embed_model = HuggingFaceEmbeddings(model_name="mixedbread-ai/mxbai-embed-large-v1")
+# Crea un objeto Chroma con el nombre de la colección
+vectorstore = Chroma(
+    collection_name="reformas_construccion_juancarlos_y_yoises",
+    embedding_function=embed_model,
 )
+# Agrega los textos a la colección
+vectorstore.add_texts(context_data)
+# Crea un objeto retriever con la colección
+retriever = vectorstore.as_retriever()
+# Crea un objeto PromptTemplate con el prompt
+template = ("""Tu eres un experto asistente de Gnostic Dev, especializado en desarrollo web, diseño de páginas web,
+plataformas e-commerce y aplicaciones con inteligencia artificial. Debes responder a preguntas técnicas de posibles clientes de manera clara
+y concisa, proporcionando soluciones efectivas y personalizadas. Recuerda que para cualquier duda o consulta adicional,
+los clientes pueden contactar conmigo a través del chat que se encuentra en la parte inferior derecha de la pantalla,
+y me pondré en contacto con ellos lo antes posible.
+Destaca las ventajas de contratar mis servicios como freelancer,
+incluyendo precios competitivos, soporte técnico personalizado e ilimitado, y la inclusión de una versión APK como aplicación para Android
+para cada proyecto web, así como un chatbot y asistente. Además, resalta mi experiencia y habilidades en el desarrollo de soluciones
+web personalizadas y mi compromiso con la satisfacción del cliente. cuando te pregunten cual es el proceso de comprar y encargar un proyecto conmigo
+les diras que a diferencia del resto, solo en gnostic dev es posible pagar tu web al final del trabajo,
+todas las web con facil administacion para inexpertos,
+    Context: {context}
+    Question: {question}
+    Answer:""")
+# Crea un objeto rag_prompt con el prompt
+rag_prompt = PromptTemplate.from_template(template)
+# Crea un objeto StrOutputParser para parsear la salida
+from langchain_core.output_parsers import StrOutputParser
+# Crea un objeto RunnablePassthrough para ejecutar el modelo
+from langchain_core.runnables import RunnablePassthrough
+# Crea un objeto rag_chain con el modelo y el prompt
+rag_chain = (
+    {"context": retriever, "question": RunnablePassthrough()}
+    | rag_prompt
+    | llm
+    | StrOutputParser()
+)
+# Importa la biblioteca Gradio
+import gradio as gr
+# Crea una función para procesar la entrada del usuario
+def rag_memory_stream(message, history):
+    partial_text = ""
+    for new_text in rag_chain.stream(message):
+        partial_text += new_text
+        yield partial_text
+# Crea un objeto Gradio con la función y el título
+examples = [
+    "¿Cómo encargar mi web contigo?",
+    "¿Como limpiar un wordpress hackeado?",
+    "¿Cómo importar productos en wooocommerce?"
+]
+description = "Aplicación de IA desarrollada por GnoscticDev para servirle :)"
+title = "Experto en desarrollo web"
+demo = gr.ChatInterface(fn=rag_memory_stream,
+                        type="messages",
+                        title=title,
+                        description=description,
+                        fill_height=True,
+                        examples=examples,
+                        theme="glass",
+)