Refactor vector search example to use sync API

examples/vector_search_example.py

@@ -1,12 +1,6 @@
 #!/usr/bin/env python3
-"""
-Ejemplo de uso del módulo de búsqueda vectorial de herramientas ATDF.
+"""Ejemplo síncrono de uso del almacén vectorial de herramientas ATDF."""
 
-Este script demuestra cómo utilizar el módulo ATDFVectorStore para
-indexar y buscar herramientas ATDF utilizando vectores semánticos.
-"""
-
-import asyncio
 import json
 import os
 import sys
@@ -24,13 +18,9 @@
 DB_PATH = os.path.join(os.path.dirname(__file__), "..", "examples", "vector_db")
 
 
-async def create_index() -> ATDFVectorStore:
-    """
-    Crear un índice vectorial a partir de herramientas de ejemplo.
+def create_index() -> ATDFVectorStore:
+    """Crear un índice vectorial a partir de herramientas de ejemplo."""
 
-    Returns:
-        Instancia de ATDFVectorStore inicializada
-    """
     print(f"Cargando herramientas desde {TOOLS_DIR}...")
     tools = load_tools_from_directory(Path(TOOLS_DIR))
 
@@ -41,32 +31,23 @@ async def create_index() -> ATDFVectorStore:
 
     print(f"Se cargaron {len(tools)} herramientas")
 
-    # Crear almacén vectorial
     vector_store = ATDFVectorStore(db_path=DB_PATH)
-
-    # Inicializar y crear índice
-    await vector_store.initialize()
     print("Creando índice vectorial...")
 
-    success = await vector_store.create_from_tools(tools)
-    if not success:
-        print("Error al crear índice vectorial")
+    added = vector_store.add_tools_sync(tools)
+    if added == 0:
+        print("No se pudo indexar ninguna herramienta")
         sys.exit(1)
 
-    tool_count = await vector_store.count_tools()
+    tool_count = len(vector_store.get_all_tools_sync())
     print(f"Índice creado correctamente con {tool_count} herramientas")
 
     return vector_store
 
 
-async def search_examples(vector_store: ATDFVectorStore) -> None:
-    """
-    Realizar búsquedas de ejemplo.
+def search_examples(vector_store: ATDFVectorStore) -> None:
+    """Realizar búsquedas de ejemplo."""
 
-    Args:
-        vector_store: Instancia de ATDFVectorStore inicializada
-    """
-    # Ejemplos de consultas
     examples = [
         "herramienta para buscar en archivos",
         "como puedo ejecutar un comando en la terminal",
@@ -83,34 +64,28 @@ async def search_examples(vector_store: ATDFVectorStore) -> None:
         print(f"\nConsulta: '{query}'")
         print("-" * 40)
 
-        # Realizar búsqueda
-        results = await vector_store.search_tools(query=query, options={"limit": 3})
+        results = vector_store.search(query=query, options={"limit": 3})
 
         if not results:
             print("No se encontraron resultados")
             continue
 
-        # Mostrar resultados
         print(f"Se encontraron {len(results)} resultados:")
 
         for i, result in enumerate(results):
             score = result.get("score", 0)
             score_percent = int(score * 100)
-
             print(f"  [{i+1}] {result.get('name')} ({score_percent}% relevancia)")
 
     print("\n" + "=" * 80)
     print("EJEMPLO CON FILTROS")
     print("=" * 80)
 
-    # Ejemplo con filtros
     query = "buscar información"
     print(f"\nConsulta: '{query}' (filtrado por categoría 'data')")
     print("-" * 40)
 
-    results = await vector_store.search_tools(
-        query=query, options={"limit": 5, "category": "data"}
-    )
+    results = vector_store.search(query=query, options={"limit": 5, "category": "data"})
 
     if not results:
         print("No se encontraron resultados")
@@ -120,32 +95,32 @@ async def search_examples(vector_store: ATDFVectorStore) -> None:
         for i, result in enumerate(results):
             score = result.get("score", 0)
             score_percent = int(score * 100)
-
             print(f"  [{i+1}] {result.get('name')} ({score_percent}% relevancia)")
 
-            # Mostrar metadatos si existen
-            if "metadata" in result and result["metadata"]:
+            metadata_payload = result.get("metadata")
+            if metadata_payload:
                 try:
-                    metadata = json.loads(result["metadata"])
-                    if "category" in metadata:
-                        print(f"      Categoría: {metadata['category']}")
-                    if "tags" in metadata and metadata["tags"]:
-                        print(f"      Etiquetas: {', '.join(metadata['tags'])}")
-                except:
-                    pass
+                    metadata = json.loads(metadata_payload)
+                except (TypeError, json.JSONDecodeError):
+                    metadata = metadata_payload if isinstance(metadata_payload, dict) else None
 
+                if isinstance(metadata, dict):
+                    category = metadata.get("category")
+                    if category:
+                        print(f"      Categoría: {category}")
+                    tags = metadata.get("tags")
+                    if tags:
+                        print(f"      Etiquetas: {', '.join(tags)}")
 
-async def main():
+
+def main() -> None:
     """Función principal del script de ejemplo."""
-    # Crear directorio para la base de datos si no existe
-    os.makedirs(DB_PATH, exist_ok=True)
 
-    # Crear índice
-    vector_store = await create_index()
+    os.makedirs(DB_PATH, exist_ok=True)
 
-    # Realizar búsquedas de ejemplo
-    await search_examples(vector_store)
+    vector_store = create_index()
+    search_examples(vector_store)
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

sdk/atdf_sdk.py

@@ -143,7 +143,11 @@ def find_tools_by_text(
                 options["limit"] = limit
 
             try:
-                results = self.vector_store.search_tools_sync(query, options)
+                search_fn = getattr(self.vector_store, "search", None)
+                if search_fn is None:
+                    search_fn = self.vector_store.search_tools_sync
+
+                results = search_fn(query, options)
 
                 tools_with_scores: List[Tuple[ATDFTool, float]] = []
                 for tool_data in results or []:
@@ -463,7 +467,11 @@ def search_tools(
             )
 
         # Realizar búsqueda vectorial
-        results = self.vector_store.search_tools_sync(
+        search_fn = getattr(self.vector_store, "search", None)
+        if search_fn is None:
+            search_fn = self.vector_store.search_tools_sync
+
+        results = search_fn(
             query, {"limit": limit, "score_threshold": score_threshold}
         )
 

sdk/vector_search/vector_store.py

@@ -483,6 +483,15 @@ def search_tools_sync(
     ) -> List[Dict[str, Any]]:
         return self._run_blocking(self.search_tools(query, options))
 
+    def search(
+        self,
+        query: str,
+        options: Optional[Dict[str, Any]] = None,
+    ) -> List[Dict[str, Any]]:
+        """Realizar una búsqueda utilizando la API síncrona."""
+
+        return self.search_tools_sync(query, options)
+
     def find_best_tool_sync(
         self,
         query: str,