from langchain.llms import HuggingFace
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.indexes import RagIndex
from langchain.retrievers import HuggingFaceRetriever

# Inicializar el modelo LLaMA 3.2 desde Hugging Face
llm = HuggingFace(model="meta-llama/Llama-3.2-1B")

# Crear un prompt para la similitud de coseno
prompt_template = (
    "Dado el siguiente par de frases, calcula la similitud de coseno: "
    "Frase 1: '{phrase_1}' y Frase 2: '{phrase_2}'. "
    "Proporciona solo el puntaje de similitud de coseno como un número entre 0 y 1."
)

# Crear el template de prompt
prompt = PromptTemplate.from_template(prompt_template)

# Crear un RAG Index usando LangChain y Hugging Face Retriever
retriever = HuggingFaceRetriever.from_pretrained(
    "facebook/rag-token-nq", index_name="exact"
)
index = RagIndex(retriever=retriever)

# Crear la cadena LLM con el modelo LLaMA y el prompt
llm_chain = LLMChain(llm=llm, prompt=prompt)

# Definir las frases para calcular la similitud de coseno
phrase_1 = "Deep learning involves neural networks for complex data patterns."
phrase_2 = "Neural networks are core components in deep learning."

# Ejecutar la cadena con las frases dadas
result = llm_chain.run(phrase_1=phrase_1, phrase_2=phrase_2)

# Imprimir el puntaje de similitud de coseno
print(f"Cosine Similarity Score: {result}")



'''
import pandas as pd
from langchain.chains import LLMChain, RAGChain
from langchain.prompts import PromptTemplate
from langchain_community.llms import HuggingFaceHub
from langchain.llms.rag import RagIndex
import streamlit as st
import sys
import re
from transformers import LlamaForCausalLM, AutoTokenizer
from huggingface_hub import login

# Inicialización de Hugging Face
huggingface_token = st.secrets["SECRET"]
login(huggingface_token)

# Cargar archivo CSV
uploaded_file = st.file_uploader("Sube un archivo CSV con la columna 'job_title':", type=["csv"])

if uploaded_file:
    df = pd.read_csv(uploaded_file)
    st.dataframe(df)

    query = "aspiring human resources specialist"

    # Modelo LLaMA
    model_name = "meta-llama/Llama-3.2-1B"
    modelo = LlamaForCausalLM.from_pretrained(model_name)

    # Tokenizador
    try:
        tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
        print("Tokenizador cargado con éxito.")
    except Exception as e:
        print(f"Error al cargar el tokenizador: {e}")
        sys.exit(1)

    # Prompt para cadena LLM
    prompt_template = PromptTemplate(
        input_variables=["query", "texto"],
        template=(
            "Calcular el cosine similarity score entre '{query}' y '{texto}'. "
            "Responde solo con un número entre 0 y 1 en formato float, sin texto adicional."
        )
    )

    # Cargar índice RAG
    rag_index = RagIndex.from_huggingface("meta-llama/Llama-3.2-1B")

    # Crear cadena RAG
    llm = HuggingFaceHub(repo_id=model_name, huggingfacehub_api_token=huggingface_token, model_kwargs={"max_new_tokens": 3})
    rag_chain = RAGChain(llm=llm, index=rag_index, prompt=prompt_template)

    def calcular_similitud(texto):
        prompt = {"query": query, "texto": texto}
        resultado = rag_chain.run(prompt)
        print("Resultado del modelo:", resultado)
        
        match = re.search(r"\b(0\.\d+|1\.0)\b", resultado)
        if match:
            score = float(match.group(1))
            return score
        else:
            st.error(f"No se pudo extraer el puntaje de similitud: {resultado}")
            return None

    # Calcular similitud para cada job title
    df['Score'] = df['job_title'].apply(calcular_similitud)

    # Reportar resultados
    st.write(df)
else:
    st.write("No se ha subido un archivo")
'''
'''
import pandas as pd
from langchain.chains import LLMChain
from langchain_huggingface import HuggingFacePipeline
from transformers import LlamaForCausalLM, AutoTokenizer
from langchain.llms import HuggingFaceHub
from huggingface_hub import login
import streamlit as st
import sys

# Inicialización de Hugging Face
huggingface_token = st.secrets["SECRET"]
login(huggingface_token)

# Cargar el archivo CSV
uploaded_file = st.file_uploader("Sube un archivo CSV con la columna 'job_title':", type=["csv"])

if uploaded_file:
    df = pd.read_csv(uploaded_file)
    st.dataframe(df)

    # Ingreso del query
    query = "aspiring human resources specialist"

    # Crear un modelo LLaMA
    model_name = "meta-llama/Llama-3.2-1B"  # Usa un nombre de modelo válido en Hugging Face
    modelo = LlamaForCausalLM.from_pretrained(model_name)

    try:
        # Usar AutoTokenizer para manejar automáticamente el tokenizador adecuado
        tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
        print("Tokenizador cargado con éxito.")
    except Exception as e:
        print(f"Error al cargar el tokenizador: {e}")
        sys.exit(1)

    # Crear una cadena LLM con LangChain usando HuggingFaceHub
    llm = HuggingFaceHub(repo_id=model_name, model_kwargs={"device_map": "auto"}, huggingfacehub_api_token=huggingface_token)
    chain = LLMChain(llm=llm)

    def calcular_similitud(texto):
        prompt = f"Calcular el cosine similarity score entre '{query}' y '{texto}'. Responde con el score como un valor numérico entre 0 y 1."
        resultado = chain.run(prompt)
        return float(resultado)

    # Calcular la similitud para cada job title
    df['Score'] = df['job_title'].apply(calcular_similitud)

    # Reportar los resultados
    st.write(df)
else:
    st.write("No se ha subido un archivo")
'''