Update app.py

app.py

@@ -1,4 +1,134 @@
 import gradio as gr
+from llama_index.core import VectorStoreIndex
+from llama_index.core import (
+    StorageContext,
+    load_index_from_storage,
+)
+from llama_index.tools.arxiv import ArxivToolSpec
+from llama_index.core import Settings
+from llama_index.llms.azure_openai import AzureOpenAI
+from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
+from llama_index.llms.openai import OpenAI
+from llama_index.embeddings.openai import OpenAIEmbedding
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+import json
+import os
+import asyncio
+
+
+##### LLM #####
+openai_api_key = os.environ.get('OPENAI_API_KEY')
+
+
+llm = OpenAI(
+    model="gpt-4.1",
+    api_key=openai_api_key,
+)
+embed_model = OpenAIEmbedding(
+    model="text-embedding-ada-002",
+    api_key=openai_api_key,
+)
+
+Settings.llm = llm
+Settings.embed_model = embed_model
+##### END LLM #####
+
+
+
+##### LOAD RETRIEVERS #####
+DOCUMENTS_BASE_PATH = "./"
+RETRIEVERS_JSON_PATH = Path("./retrievers.json")
+
+# Cargar metadatos
+def load_retrievers_metadata():
+    try:
+        with open(RETRIEVERS_JSON_PATH, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Error cargando retrievers.json: {str(e)}", exc_info=True)
+        return {}
+
+retrievers_metadata = load_retrievers_metadata()
+SOURCES = {source: f"{source.lower()}/" for source in retrievers_metadata.keys()}
+
+# Cargar índices
+indices: Dict[str, VectorStoreIndex] = {}
+
+for source, rel_path in SOURCES.items():
+    full_path = os.path.join(DOCUMENTS_BASE_PATH, rel_path)
+    if not os.path.exists(full_path):
+        logger.warning(f"No se encontró la ruta para {source}")
+        continue
+
+    for root, dirs, files in os.walk(full_path):
+        if "storage_nodes" in dirs:
+            try:
+                storage_path = os.path.join(root, "storage_nodes")
+                storage_context = StorageContext.from_defaults(persist_dir=storage_path)
+                index_name = os.path.basename(root)
+                indices[index_name] = load_index_from_storage(storage_context) #, index_id="vector_index"
+                logger.info(f"Índice cargado correctamente: {index_name}")
+            except Exception as e:
+                logger.error(f"Error cargando índice {index_name}: {str(e)}", exc_info=True)
+                
+
+
+
+
+arxiv_tool = ArxivToolSpec(max_results=5).to_tool_list()[0]
+arxiv_tool.return_direct = True
+
+async def search_arxiv(
+    query: str,
+    max_results: int = 5
+) -> Dict[str, Any]:
+    """
+    Busca artículos académicos en ArXiv.
+    
+    Args:
+        query: Términos de búsqueda (ej. "deep learning")
+        max_results: Número máximo de resultados (1-10, default 5)
+    
+    Returns:
+        Dict: Resultados de la búsqueda con metadatos de los papers
+    """
+    try:
+        # Configurar máximo de resultados
+        max_results = min(max(1, max_results), 10)
+        arxiv_tool.metadata.max_results = max_results
+        
+        # Ejecutar búsqueda y obtener resultados
+        tool_output = arxiv_tool(query=query)
+        
+        # Procesar documentos
+        papers = []
+        for doc in tool_output.raw_output:  # Acceder correctamente a los documentos
+            content = doc.text_resource.text.split('\n')
+            papers.append({
+                'title': content[0].split(': ')[1] if ': ' in content[0] else content[0],
+                'abstract': '\n'.join(content[1:]).strip(),
+                'pdf_url': content[0].split(': ')[0].replace('http://', 'https://'),
+                'arxiv_id': content[0].split(': ')[0].split('/')[-1].replace('v1', '')
+            })
+        
+        return {
+            'papers': papers,
+            'count': len(papers),
+            'query': query,
+            'status': 'success'
+        }
+        
+    except Exception as e:
+        return {
+            'papers': [],
+            'count': 0,
+            'query': query,
+            'status': 'error',
+            'error': str(e)
+        }
+
+
 
 def letter_counter(word, letter):
     """Count the occurrences of a specific letter in a word.