Temporarily disable HuggingFace model integration and simplify FastAPI endpoints

- Comment out HuggingFace client initialization
- Remove model calling and graph configuration
- Simplify root endpoint with more descriptive function name
- Comment out generate and test-token endpoints

app.py

@@ -6,93 +6,93 @@ from langchain_core.messages import HumanMessage, AIMessage
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.graph import START, MessagesState, StateGraph
 
-# Inicializar el cliente de HuggingFace
-client = InferenceClient(
-    model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
-)
-
-# Define the graph
-workflow = StateGraph(state_schema=MessagesState)
+# Initialize the HuggingFace client
+# client = InferenceClient(
+#     model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+# )
 
 # Define the function that calls the model
-def call_model(state: MessagesState):
-    # 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):
+#     # 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})
     
-    # Llamar a la API
-    response = client.chat_completion(
-        messages=hf_messages,
-        temperature=0.5,
-        max_tokens=64,
-        top_p=0.7
-    )
+#     # Call the API
+#     response = client.chat_completion(
+#         messages=hf_messages,
+#         temperature=0.5,
+#         max_tokens=64,
+#         top_p=0.7
+#     )
     
-    # Convertir respuesta a formato LangChain
-    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)
 
-# Definir el nodo en el grafo
-workflow.add_edge(START, "model")
-workflow.add_node("model", call_model)
+# Define the node in the graph
+# workflow.add_edge(START, "model")
+# workflow.add_node("model", call_model)
 
-# Agregar memoria
-memory = MemorySaver()
-graph_app = workflow.compile(checkpointer=memory)
+# Add memory
+# memory = MemorySaver()
+# graph_app = workflow.compile(checkpointer=memory)
 
-# Definir el modelo de datos para la solicitud
-class QueryRequest(BaseModel):
-    query: str
-    thread_id: str = "default"
+# Define the data model for the request
+# 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")
 
 @app.get("/")
-async def root():
+async def api_home():
     """Welcome endpoint"""
     return {"detail": "Welcome to FastAPI, Langchain, Docker tutorial"}
 
-@app.post("/generate")
-async def generate(request: QueryRequest):
-    """Endpoint to generate text using the language model"""
-    try:
-        # Configure the thread ID
-        config = {"configurable": {"thread_id": request.thread_id}}
+# @app.post("/generate")
+# async def generate(request: QueryRequest):
+#     """Endpoint to generate text using the language model"""
+#     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)}")
 
 # Add an endpoint to test the token directly
-@app.get("/test-token")
-async def test_token():
-    """Endpoint to test the authentication with HuggingFace"""
-    try:
-        # Make a simple request to verify that the token works
-        response = client.chat_completion(
-            messages=[{"role": "user", "content": "Hello"}],
-            max_tokens=10
-        )
-        return {"status": "success", "message": "Token is valid", "response": response.choices[0].message.content}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
+# @app.get("/test-token")
+# async def test_token():
+#     """Endpoint to test the authentication with HuggingFace"""
+#     try:
+#         # Make a simple request to verify that the token works
+#         response = client.chat_completion(
+#             messages=[{"role": "user", "content": "Hello"}],
+#             max_tokens=10
+#         )
+#         return {"status": "success", "message": "Token is valid", "response": response.choices[0].message.content}
+#     except Exception as e:
+#         return {"status": "error", "message": str(e)}
 
 if __name__ == "__main__":
     import uvicorn