Update app.py

app.py

@@ -194,6 +194,88 @@ async def list_retrievers(source: str = None) -> dict:
         }
 
 
+def retrieve_docs(
+    query: str,
+    retrievers: List[str],
+    top_k: int = 3
+) -> dict:
+    """
+    Realiza búsqueda semántica en documentos indexados.
+    
+    Parámetros:
+        query (str): Texto de búsqueda (requerido)
+        retrievers (List[str]): Nombres de retrievers a consultar (requerido)
+        top_k (int): Número de resultados por retriever (opcional, default=3)
+    """
+    print(f"Iniciando búsqueda para query: '{query}'")
+    print(f"Parámetros - retrievers: {retrievers}, top_k: {top_k}")
+    
+    results = {}
+    invalid = []
+    
+    for name in retrievers:
+        if name not in indices:
+            print(f"Retriever no encontrado: {name}")
+            invalid.append(name)
+            continue
+            
+        try:
+            print(f"Procesando retriever: {name}")
+            retriever = indices[name].as_retriever(similarity_top_k=top_k)
+            nodes = retriever.retrieve(query)
+            print(f"Retrieved {len(nodes)} documentos de {name}")
+            
+            # 2. Buscar metadatos COMPLETOS
+            metadata = {}
+            source = "unknown"
+            for src, indexes in retrievers_metadata.items():
+                if name in indexes:
+                    metadata = indexes[name]
+                    source = src
+                    break
+            print(f"Metadatos encontrados para {name}: {metadata.keys()}")
+            
+            # 3. Construir respuesta
+            results[name] = {
+                "title": metadata.get("title", name),
+                "documents": [
+                    {
+                        "content": node.get_content(),
+                        "metadata": node.metadata,
+                        "score": node.score
+                    }
+                    for node in nodes
+                ],
+                "description": metadata.get("description", ""),
+                "source": source,
+                "last_updated": metadata.get("last_updated", "")
+            }
+            print(f"Retriever {name} procesado exitosamente")
+            
+        except Exception as e:
+            print(f"Error procesando retriever {name}: {str(e)}", exc_info=True)
+            results[name] = {
+                "error": str(e),
+                "retriever": name
+            }
+    
+    # Construir respuesta final
+    response = {
+        "query": query,
+        "results": results,
+        "top_k": top_k,
+    }
+    
+    if invalid:
+        print(f"Retrievers inválidos: {invalid}. Opciones válidas: {list(indices.keys())}")
+        response["warnings"] = {
+            "invalid_retrievers": invalid,
+            "valid_options": list(indices.keys())
+        }
+    
+    print(f"Búsqueda completada. Total resultados: {len(results)}")
+    return response
+
 
 async def search_tavily(
     query: str,
@@ -267,16 +349,18 @@ with gr.Blocks(title="Herramientas MCP", theme=gr.themes.Base()) as arxiv_tab:
         ],
         outputs=gr.JSON(label="Resultados de búsqueda"),
         title="Búsqueda en ArXiv",
-        description="Busca artículos académicos en ArXiv por palabras clave."
+        description="Busca artículos académicos en ArXiv por palabras clave.",
+        api_name="_search_arxiv"
     )
 
-with gr.Blocks(title="Herramientas MCP", theme=gr.themes.Base()) as retrievers_tab:
+with gr.Blocks(title="Herramientas MCP", theme=gr.themes.Base()) as list_retrievers_tab:
     retrievers_interface = gr.Interface(
         fn=list_retrievers,
         inputs=gr.Textbox(label="Fuente (opcional)", placeholder="Dejar vacío para listar todos"),
         outputs=gr.JSON(label="Lista de retrievers"),
         title="Lista de Retrievers",
-        description="Muestra los retrievers disponibles, opcionalmente filtrados por fuente."
+        description="Muestra los retrievers disponibles, opcionalmente filtrados por fuente.",
+        api_name="_list_retrievers"
     )
 
 with gr.Blocks(title="Herramientas MCP", theme=gr.themes.Base()) as tavily_tab:
@@ -290,13 +374,35 @@ with gr.Blocks(title="Herramientas MCP", theme=gr.themes.Base()) as tavily_tab:
         ],
         outputs=gr.JSON(label="Resultados de Tavily"),
         title="Búsqueda Web (Tavily)",
-        description="Realiza búsquedas en web usando la API de Tavily."
+        description="Realiza búsquedas en web usando la API de Tavily.",
+        api_name="_search_tavily"
+    )
+    
+with gr.Blocks(title="Herramientas MCP", theme=gr.themes.Base()) as retrieve_tab:
+    # Interfaz para retrieve_docs
+    retrieve_interface = gr.Interface(
+        fn=retrieve_docs,
+        inputs=[
+            gr.Textbox(label="Consulta", placeholder="Ingrese su pregunta o términos de búsqueda..."),
+            gr.Dropdown(
+                choices=list(indices.keys()),
+                label="Retrievers",
+                multiselect=True,
+                info="Seleccione uno o más retrievers"
+            ),
+            gr.Slider(1, 10, value=3, step=1, label="Número de resultados por retriever (top_k)")
+        ],
+        outputs=gr.JSON(label="Resultados de búsqueda semántica"),
+        title="Búsqueda Semántica en Documentos",
+        description="""Realiza búsqueda semántica en documentos indexados usando retrievers.
+                    Seleccione los retrievers disponibles y ajuste el número de resultados.""",
+        api_name="_retrieve"
     )
 
 # Creamos la interfaz con las pestañas separadas
 demo = gr.TabbedInterface(
-    [arxiv_tab, retrievers_tab, tavily_tab],
-    ["ArXiv", "Retrievers", "Tavily"]
+    [arxiv_tab, tavily_tab, list_retrievers_tab, retrieve_tab],
+    ["ArXiv", "Tavily", "List Retrievers", "Retrieve"]
 )
 
 demo.launch(mcp_server=True)