Update server.py

server.py

@@ -8,7 +8,7 @@ from llama_index.core import (
 from llama_index.core import Settings
 from llama_index.llms.azure_openai import AzureOpenAI
 from llama_index.embeddings.azure_openai import AzureOpenAIEmbedding
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 import json
 import os
 import aiohttp  # Necesario para las peticiones HTTP asíncronas
@@ -86,36 +86,121 @@ mcp = FastMCP("OnBase", port=port)
 
 
 
+
+@mcp.resource(
+    uri="info://available_retrievers",
+    name="AvailableRetrievers",
+    description="Provides information about available document retrievers including their names and descriptions.",
+    mime_type="application/json"
+)
+def get_available_retrievers() -> dict:
+    """
+    Returns a mapping of available retrievers with their metadata.
+    
+    The structure includes:
+    - retriever_name: The full name used to reference the retriever
+    - source: The source system (e.g., 'oms')
+    - index_name: The specific index name
+    - description: Human-readable description
+    """
+    available_retrievers = []
+    
+    for full_index_name in indices.keys():
+        # Parse the full index name (e.g., "oms_vec_1")
+        parts = full_index_name.split('_')
+        source = parts[0]
+        index_name = '_'.join(parts[1:]) if len(parts) > 1 else "default"
+        
+        # Create a description based on the index name
+        description = f"Documentos de {source.upper()}"
+        if index_name.startswith("vec"):
+            description += f" - Índice vectorial {index_name.split('_')[-1]}"
+        elif index_name.startswith("tree"):
+            description += f" - Índice jerárquico {index_name.split('_')[-1]}"
+        else:
+            description += f" - Índice {index_name}"
+        
+        available_retrievers.append({
+            "retriever_name": full_index_name,
+            "source": source,
+            "index_name": index_name,
+            "description": description
+        })
+    
+    return {
+        "retrievers": available_retrievers,
+        "count": len(available_retrievers),
+        "default_source": "oms",
+        "default_top_k": 3
+    }
+
+
+
+
+
 @mcp.tool()
-def retrieve_docs(query: str, fuente: str = 'oms', top_k: int = 3) -> dict:
+def retrieve_docs(
+    query: str,
+    retrievers: List[str],
+    top_k: int = 3
+) -> dict:
     """
     Retrieve documents from different regulations using semantic search.
     
     Parameters:
         query: Search query (required).
-        fuente: Source name (default: 'oms').
-        top_k: Number of results to return (default: 3).
+        retrievers: List of specific retriever names to use (required).
+        top_k: Number of results to return per retriever (default: 3).
+    
+    Example:
+        retrieve_docs(
+            query="salud pública",
+            retrievers=["oms_vec_1", "oms_tree_2"],
+            top_k=2
+        )
     """
     if not query:
         return {"error": "Query parameter is required"}
     
-    if fuente not in indices:
-        available = [k for k in indices.keys() if k.startswith("oms_")] if fuente.startswith("oms") else list(indices.keys())
-        return {"error": f"Fuente '{fuente}' no disponible. Opciones: {available}"}
-    
-    retriever = indices[fuente].as_retriever(similarity_top_k=top_k)
-    nodes = retriever.retrieve(query)
+    if not retrievers:
+        return {"error": "At least one retriever must be specified", "available_retrievers": list(indices.keys())}
     
-    results = [
-        {
-            "content": node.get_content(),
-            "metadata": node.metadata,
-            "score": node.score
+    # Verificar que todos los retrievers solicitados existan
+    invalid_retrievers = [r for r in retrievers if r not in indices]
+    if invalid_retrievers:
+        return {
+            "error": f"Invalid retrievers specified: {invalid_retrievers}",
+            "available_retrievers": list(indices.keys())
         }
-        for node in nodes
-    ]
     
-    return {"results": results}
+    results = {}
+    
+    for retriever_name in retrievers:
+        try:
+            retriever = indices[retriever_name].as_retriever(similarity_top_k=top_k)
+            nodes = retriever.retrieve(query)
+            
+            results[retriever_name] = [
+                {
+                    "content": node.get_content(),
+                    "metadata": node.metadata,
+                    "score": node.score
+                }
+                for node in nodes
+            ]
+        except Exception as e:
+            results[retriever_name] = {
+                "error": f"Error retrieving documents: {str(e)}"
+            }
+    
+    return {
+        "results": results,
+        "query": query,
+        "retrievers_used": retrievers,
+        "top_k": top_k,
+        "successful_retrievers": [r for r in retrievers if isinstance(results[r], list)],
+        "failed_retrievers": [r for r in retrievers if not isinstance(results[r], list)]
+    }