Update app.py

app.py

@@ -23,15 +23,26 @@ from typing_extensions import TypedDict
 # Configuración de Ollama y su servicio
 OLLAMA = os.path.expanduser("~/ollama")
 
-def download_ollama_model(model_name='hf.co/MaziyarPanahi/Llama-3.2-3B-Instruct-uncensored-GGUF:IQ1_S'):
+# Función para instalar Ollama
+def install_ollama():
+    try:
+        print("Instalando Ollama...")
+        subprocess.run("curl -fsSL https://ollama.com/install.sh | sh", shell=True, check=True)
+        print("Ollama instalado con éxito.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error al instalar Ollama: {e}")
+        raise
+
+# Función para descargar el modelo de Ollama
+async def download_ollama_model(model_name='hf.co/MaziyarPanahi/Llama-3.2-3B-Instruct-uncensored-GGUF:IQ1_S'):
     try:
         if not os.path.exists(OLLAMA):
             print("Ollama no encontrado, descargando...")
-            subprocess.run("curl -fsSL https://ollama.com/install.sh | sh", shell=True)
+            subprocess.run("curl -L https://ollama.com/download/ollama-linux-amd64 -o ~/ollama", shell=True)
             os.chmod(OLLAMA, 0o755)
         
         print(f"Descargando el modelo: {model_name}")
-        subprocess.run(["ollama", "pull", model_name], check=True)
+        subprocess.run(["~/ollama", "pull", model_name], check=True)
     except subprocess.CalledProcessError as e:
         print(f"Error al descargar el modelo: {e}")
         raise
@@ -40,7 +51,7 @@ def download_ollama_model(model_name='hf.co/MaziyarPanahi/Llama-3.2-3B-Instruct-
 async def async_download_ollama_model():
     await asyncio.to_thread(download_ollama_model)
 
-# Iniciar el servidor Ollama en un hilo
+# Iniciar el servicio de Ollama en un hilo
 def ollama_service_thread():
     print("Iniciando el servicio de Ollama")
     subprocess.run("~/ollama serve", shell=True)
@@ -134,25 +145,25 @@ class GraphState(TypedDict):
     context: str
 
 # Nodos de procesamiento
-def generate(state):
+async def generate(state):
     print("Step: Generating Final Response")
     question = state["question"]
     context = state["context"]
-    generation = generate_chain.invoke({"context": context, "question": question})
+    generation = await asyncio.to_thread(generate_chain.invoke, {"context": context, "question": question})
     return {"generation": generation}
 
-def transform_query(state):
+async def transform_query(state):
     print("Step: Optimizing Query for Web Search")
     question = state['question']
-    gen_query = query_chain.invoke({"question": question})
+    gen_query = await asyncio.to_thread(query_chain.invoke, {"question": question})
     search_query = gen_query.get("query", "")  # Asegurarnos de que estamos obteniendo la clave correcta
     return {"search_query": search_query}
 
-def web_search(state):
+async def web_search(state):
     search_query = state['search_query']
     print(f'Step: Searching the Web for: "{search_query}"')
     try:
-        search_result = web_search_tool.invoke(search_query)
+        search_result = await asyncio.to_thread(web_search_tool.invoke, search_query)
         if isinstance(search_result, str):  # Si la respuesta es una cadena, la convertimos en un diccionario
             print(f"Respuesta de búsqueda web es cadena: {search_result}")
             return {"context": search_result}
@@ -164,10 +175,10 @@ def web_search(state):
         print(f"Web search failed: {e}")
         return None  # Si la búsqueda falla, no devuelve contexto
 
-def route_question(state):
+async def route_question(state):
     print("Step: Routing Query")
     question = state['question']
-    output = question_router.invoke({"question": question})
+    output = await asyncio.to_thread(question_router.invoke, {"question": question})
     if output.get('choice') == "web_search":
         print("Step: Routing Query to Web Search")
         return "websearch"
@@ -196,18 +207,15 @@ workflow.add_edge("generate", END)
 local_agent = workflow.compile()
 
 # Función para ejecutar el agente
-def run_agent_parallel(query):
-    output = local_agent.invoke({"question": query})
-    if "generation" not in output:  # Si la búsqueda web falló y no hubo respuesta de generación
-        print("Web search failed, using Ollama model directly.")
-        return generate({"question": query, "context": ""})["generation"]  # Generar directamente
+async def run_agent_parallel(query):
+    output = await asyncio.to_thread(local_agent.invoke, {"question": query})
     return output['generation']
 
 # Lógica del servidor FastAPI
 @app.post("/query")
 async def query_endpoint(request: QueryRequest):
     query = request.query
-    return {"response": run_agent_parallel(query)}
+    return {"response": await run_agent_parallel(query)}
 
 # Lógica de recursos
 def release_resources():
@@ -249,4 +257,4 @@ def resource_manager():
 resource_manager()
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=7860)