medium

app.py

@@ -1,72 +1,146 @@
+import os
+from dotenv import load_dotenv
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from typing import TypedDict, Annotated, Literal
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
 import gradio as gr
-from langgraph.graph import StateGraph, END
-from langchain_core.runnables import RunnableLambda
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import torch
-
-# 1. Preparar el modelo Qwen/Qwen1.5-32B-Chat
-model_id = "Qwen/Qwen1.5-32B-Chat"
-
-tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
-model = AutoModelForCausalLM.from_pretrained(
-    model_id,
-    device_map="auto",
-    torch_dtype=torch.float16,
-    trust_remote_code=True
+
+load_dotenv()
+
+# Configuración
+max_tokens = 2000
+num_iterations = 2
+quality_threshold = 8
+
+# Base de datos simulada de destinos turísticos
+travel_database = {
+    "paris": {"destination": "Paris", "price": 1500, "features": ["romantic", "cultural", "historic"]},
+    "bali": {"destination": "Bali", "price": 1200, "features": ["beach", "relaxing", "adventurous"]},
+    "new_york": {"destination": "New York", "price": 2000, "features": ["urban", "shopping", "nightlife"]},
+    "tokyo": {"destination": "Tokyo", "price": 1800, "features": ["modern", "cultural", "tech-savvy"]},
+}
+
+# Modelos estructurados para la salida de cada nodo
+class GenerateRecommendation(BaseModel):
+    destination: str = Field(description="El destino turístico recomendado")
+    explanation: str = Field(description="Explicación breve de la recomendación")
+
+class RecommendationQualityScore(BaseModel):
+    score: int = Field(description="Puntuación de la recomendación entre 1-10")
+    comment: str = Field(description="Comentario sobre la calidad de la recomendación")
+
+# Estado del grafo
+class GraphState(TypedDict):
+    messages: Annotated[list, add_messages]
+    quality: Annotated[int, 0]  # Valor inicial 0
+    iterations: Annotated[int, 0]  # Valor inicial 0
+
+# Inicialización del grafo
+builder = StateGraph(GraphState)
+
+llm = ChatOpenAI(
+    model="gpt-4o-mini",
+    temperature=0,
+    max_tokens=max_tokens,
+    api_key=os.getenv("OPENAI_API_KEY")
 )
-model.eval()
-
-# 2. Crear un wrapper manual (sin langchain)
-class QwenWrapper:
-    def invoke(self, prompt: str) -> str:
-        messages = [{"role": "user", "content": prompt}]
-        inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
-        output = model.generate(inputs, max_new_tokens=256, do_sample=True, temperature=0.7)
-        decoded = tokenizer.decode(output[0], skip_special_tokens=True)
-        return decoded.split("assistant")[-1].strip()
-
-qwen = QwenWrapper()
-
-# 3. Definir el estado del agente
-class AgentState(dict):
-    pass
-
-# 4. Paso del agente con rol de agente de viajes
-def agent_step(state: AgentState) -> AgentState:
-    user_input = state.get("input")
-    if not user_input:
-        return {"input": "", "output": "No se recibió entrada."}
-    travel_prompt = (
-        "Eres un agente de viajes profesional y experimentado. "
-        "Asesora, recomienda y planifica itinerarios, destinos y actividades de viaje según las preferencias del usuario. "
-        f"Usuario: {user_input}"
-    )
-    response = qwen.invoke(travel_prompt)
-    return {"input": user_input, "output": response}
-
-
-# 5. Crear nodo LangGraph
-agent_node = RunnableLambda(agent_step)
-
-graph_builder = StateGraph(AgentState)
-graph_builder.add_node("agent", agent_node)
-graph_builder.set_entry_point("agent")
-graph_builder.add_edge("agent", END)
-graph = graph_builder.compile()
-
-# 6. Función para Gradio
-def chat_with_agent(message):
-    result = graph.invoke({"input": message})
-    print(result)
-    return result["output"]
-
-# 7. Interfaz Gradio adaptada para un agente de viajes
+developer_structure_llm = llm.with_structured_output(GenerateRecommendation, method="json_mode")
+reviewer_structure_llm = llm.with_structured_output(RecommendationQualityScore, method="json_mode")
+
+def travel_recommender(state):
+    # Se asume que el último mensaje contiene las preferencias del usuario
+    user_requirements = state["messages"][-1].content
+    system_prompt = f"""
+    Eres un experto en recomendaciones de viajes.
+    Con base en las siguientes preferencias del usuario: {user_requirements},
+    selecciona el mejor destino de la siguiente base de datos: {travel_database}.
+    Responde en JSON con la clave `destination` para el destino recomendado y `explanation` con una breve razón de la recomendación.
+    """
+    human_messages = [msg for msg in state["messages"] if isinstance(msg, HumanMessage)]
+    ai_messages = [msg for msg in state["messages"] if isinstance(msg, AIMessage)]
+    system_messages = [SystemMessage(content=system_prompt)]
+    
+    messages = system_messages + human_messages + ai_messages
+    message = developer_structure_llm.invoke(messages)
+    
+    recommendation_output = f"Destination: {message.destination}\nExplanation: {message.explanation}"
+    # Se agrega la recomendación a los mensajes para los siguientes nodos
+    state["messages"].append(AIMessage(content=recommendation_output))
+    state["iterations"] += 1
+    return state
+
+def recommendation_review(state):
+    system_prompt = """
+    Eres un revisor de recomendaciones con altos estándares.
+    Revisa la recomendación proporcionada y asigna una puntuación de calidad entre 1-10.
+    Evalúa la relevancia, precisión y alineación con las necesidades del cliente.
+    Responde en JSON con las claves `score` y `comment`.
+    """
+    human_messages = [msg for msg in state["messages"] if isinstance(msg, HumanMessage)]
+    ai_messages = [msg for msg in state["messages"] if isinstance(msg, AIMessage)]
+    system_messages = [SystemMessage(content=system_prompt)]
+    
+    messages = system_messages + human_messages + ai_messages
+    message = reviewer_structure_llm.invoke(messages)
+    
+    review_comment = f"Review Score: {message.score}\nComment: {message.comment}"
+    state["messages"].append(AIMessage(content=review_comment))
+    state["quality"] = message.score
+    return state
+
+def final_recommendation(state):
+    system_prompt = "Revisa la recomendación final y proporciona una respuesta final para el usuario."
+    human_messages = [msg for msg in state["messages"] if isinstance(msg, HumanMessage)]
+    ai_messages = [msg for msg in state["messages"] if isinstance(msg, AIMessage)]
+    system_messages = [SystemMessage(content=system_prompt)]
+    
+    messages = system_messages + human_messages + ai_messages
+    final_message = llm.invoke(messages)
+    
+    # Se guarda la recomendación final en el estado para mostrarla
+    state["final_recommendation"] = final_message.content
+    state["messages"].append(AIMessage(content=f"Final Recommendation: {final_message.content}"))
+    return state
+
+# Función para definir la condición de la bifurcación en el grafo
+def quality_gate_condition(state) -> Literal["travel_recommender", "final_recommendation"]:
+    if state["iterations"] >= num_iterations:
+        return "final_recommendation"
+    if state["quality"] < quality_threshold:
+        return "travel_recommender"
+    else:
+        return "final_recommendation"
+
+# Agregar nodos al grafo
+builder.add_node("travel_recommender", travel_recommender)
+builder.add_node("recommendation_review", recommendation_review)
+builder.add_node("final_recommendation", final_recommendation)
+
+# Conectar nodos
+builder.add_edge(START, "travel_recommender")
+builder.add_edge("travel_recommender", "recommendation_review")
+builder.add_edge("final_recommendation", END)
+
+builder.add_conditional_edges("recommendation_review", quality_gate_condition)
+
+graph = builder.compile()
+
+# Función que ejecuta el grafo con la entrada del usuario
+def run_graph(user_input: str) -> str:
+    initial_state = {"messages": [HumanMessage(content=user_input)], "quality": 0, "iterations": 0}
+    final_state = graph.invoke(initial_state)
+    return final_state.get("final_recommendation", "No se generó una recomendación final.")
+
+# Interfaz de Gradio
 iface = gr.Interface(
-    fn=chat_with_agent,
-    inputs=gr.Textbox(lines=2, placeholder="Haz una consulta sobre viajes..."),
-    outputs="text",
-    title="Agente de Viajes con LangGraph y Qwen",
-    description="Agente de viajes que utiliza LangGraph y Qwen/Qwen1.5-32B-Chat para recomendar destinos, itinerarios y consejos de viaje."
+    fn=run_graph,
+    inputs=gr.Textbox(label="Ingrese sus preferencias de viaje"),
+    outputs=gr.Textbox(label="Recomendación Final"),
+    title="Sistema de Recomendación de Viajes"
 )
 
-iface.launch()
+if __name__ == "__main__":
+    iface.launch()