Uncomment and activate LangChain and HuggingFace integration

- Restore full model initialization and generation workflow
- Enable HuggingFace InferenceClient with Qwen2.5-72B-Instruct
- Reactivate LangGraph-based message processing endpoint
- Uncomment environment variable loading and token verification

app.py

@@ -1,70 +1,70 @@
 from fastapi import FastAPI, HTTPException
-# from pydantic import BaseModel
-# from huggingface_hub import InferenceClient
+from pydantic import BaseModel
+from huggingface_hub import InferenceClient
 
-# from langchain_core.messages import HumanMessage, AIMessage
-# from langgraph.checkpoint.memory import MemorySaver
-# from langgraph.graph import START, MessagesState, StateGraph
+from langchain_core.messages import HumanMessage, AIMessage
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import START, MessagesState, StateGraph
 
-# import os
-# from dotenv import load_dotenv
-# load_dotenv()
+import os
+from dotenv import load_dotenv
+load_dotenv()
 
-# HUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN", os.getenv("HUGGINGFACE_TOKEN"))
-# print(HUGGINGFACE_TOKEN)
+HUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN", os.getenv("HUGGINGFACE_TOKEN"))
+print(HUGGINGFACE_TOKEN)
 
 # Initialize the HuggingFace model
-# model = InferenceClient(
-#     model="Qwen/Qwen2.5-72B-Instruct",
-#     api_key=os.getenv("HUGGINGFACE_TOKEN")
-# )
+model = InferenceClient(
+    model="Qwen/Qwen2.5-72B-Instruct",
+    api_key=os.getenv("HUGGINGFACE_TOKEN")
+)
 
 # Define the function that calls the model
-# def call_model(state: MessagesState):
-#     """
-#     Call the model with the given messages
-
-#     Args:
-#         state: MessagesState
-
-#     Returns:
-#         dict: A dictionary containing the generated text and the thread ID
-#     """
-#     # Convert LangChain messages to HuggingFace format
-#     hf_messages = []
-#     for msg in state["messages"]:
-#         if isinstance(msg, HumanMessage):
-#             hf_messages.append({"role": "user", "content": msg.content})
-#         elif isinstance(msg, AIMessage):
-#             hf_messages.append({"role": "assistant", "content": msg.content})
+def call_model(state: MessagesState):
+    """
+    Call the model with the given messages
+
+    Args:
+        state: MessagesState
+
+    Returns:
+        dict: A dictionary containing the generated text and the thread ID
+    """
+    # Convert LangChain messages to HuggingFace format
+    hf_messages = []
+    for msg in state["messages"]:
+        if isinstance(msg, HumanMessage):
+            hf_messages.append({"role": "user", "content": msg.content})
+        elif isinstance(msg, AIMessage):
+            hf_messages.append({"role": "assistant", "content": msg.content})
     
-#     # Call the API
-#     response = model.chat_completion(
-#         messages=hf_messages,
-#         temperature=0.5,
-#         max_tokens=64,
-#         top_p=0.7
-#     )
+    # Call the API
+    response = model.chat_completion(
+        messages=hf_messages,
+        temperature=0.5,
+        max_tokens=64,
+        top_p=0.7
+    )
     
-#     # Convert the response to LangChain format
-#     ai_message = AIMessage(content=response.choices[0].message.content)
-#     return {"messages": state["messages"] + [ai_message]}
+    # Convert the response to LangChain format
+    ai_message = AIMessage(content=response.choices[0].message.content)
+    return {"messages": state["messages"] + [ai_message]}
 
 # Define the graph
-# workflow = StateGraph(state_schema=MessagesState)
+workflow = StateGraph(state_schema=MessagesState)
 
 # Define the node in the graph
-# workflow.add_edge(START, "model")
-# workflow.add_node("model", call_model)
+workflow.add_edge(START, "model")
+workflow.add_node("model", call_model)
 
 # Add memory
-# memory = MemorySaver()
-# graph_app = workflow.compile(checkpointer=memory)
+memory = MemorySaver()
+graph_app = workflow.compile(checkpointer=memory)
 
 # Define the data model for the request
-# class QueryRequest(BaseModel):
-#     query: str
-#     thread_id: str = "default"
+class QueryRequest(BaseModel):
+    query: str
+    thread_id: str = "default"
 
 # Create the FastAPI application
 app = FastAPI(title="LangChain FastAPI", description="API to generate text using LangChain and LangGraph")
@@ -76,38 +76,38 @@ async def api_home():
     return {"detail": "Welcome to FastAPI, Langchain, Docker tutorial"}
 
 # Generate endpoint
-# @app.post("/generate")
-# async def generate(request: QueryRequest):
-#     """
-#     Endpoint to generate text using the language model
+@app.post("/generate")
+async def generate(request: QueryRequest):
+    """
+    Endpoint to generate text using the language model
     
-#     Args:
-#         request: QueryRequest
-#         query: str
-#         thread_id: str = "default"
-
-#     Returns:
-#         dict: A dictionary containing the generated text and the thread ID
-#     """
-#     try:
-#         # Configure the thread ID
-#         config = {"configurable": {"thread_id": request.thread_id}}
+    Args:
+        request: QueryRequest
+        query: str
+        thread_id: str = "default"
+
+    Returns:
+        dict: A dictionary containing the generated text and the thread ID
+    """
+    try:
+        # Configure the thread ID
+        config = {"configurable": {"thread_id": request.thread_id}}
         
-#         # Create the input message
-#         input_messages = [HumanMessage(content=request.query)]
+        # Create the input message
+        input_messages = [HumanMessage(content=request.query)]
         
-#         # Invoke the graph
-#         output = graph_app.invoke({"messages": input_messages}, config)
+        # Invoke the graph
+        output = graph_app.invoke({"messages": input_messages}, config)
         
-#         # Get the model response
-#         response = output["messages"][-1].content
+        # Get the model response
+        response = output["messages"][-1].content
         
-#         return {
-#             "generated_text": response,
-#             "thread_id": request.thread_id
-#         }
-#     except Exception as e:
-#         raise HTTPException(status_code=500, detail=f"Error al generar texto: {str(e)}")
+        return {
+            "generated_text": response,
+            "thread_id": request.thread_id
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error al generar texto: {str(e)}")
 
 # if __name__ == "__main__":
 #     import uvicorn