Buscar documentos por similitud semántica

Punto final de búsqueda semántica con capacidades de procesamiento por lotes

get

Initiate a search operation with a query text of up to 400 words and receive the most semantically similar responses from the stored knowledge. For question-answering, convert your question into an ideal answer and submit it to receive similar real answers.

Query parameters

qstringOptional

Up to 400 words sentence for which you wish to find semantically similar chunks of knowledge.

nintegerOptional

Number of semantically similar chunks of text to return. Use 'n=3' for up to 5, and 'n=10' for more information. If you do not receive enough information, consider trying again with a larger 'n' value.

fromstring · date-timeOptional

Start of the time range for documents to be searched, in ISO 8601 format.

tostring · date-timeOptional

End of the time range for documents to be searched, in ISO 8601 format.

Responses

200

Successful retrieval of documents

application/json

400

Bad request

401

Unauthorized

404

Not found

500

Internal server error

get

HTTPcURLJavaScriptPython

GET /api/v1/documents/search/ HTTP/1.1
Host: api.rememberizer.ai
Accept: */*

{
  "data_sources": [
    {
      "name": "text",
      "documents": 1
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 18,
        "document_id": "text",
        "name": "text",
        "type": "text",
        "path": "text",
        "url": "text",
        "size": 1,
        "created_time": "2025-07-05T00:31:15.441Z",
        "modified_time": "2025-07-05T00:31:15.441Z",
        "indexed_on": "2025-07-05T00:31:15.441Z",
        "integration": {
          "id": 1,
          "integration_type": "text"
        }
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}

Ejemplos de Solicitudes

cURL

curl -X GET \
  "https://api.rememberizer.ai/api/v1/documents/search/?q=Cómo%20integrar%20Rememberizer%20con%20aplicaciones%20personalizadas&n=5&from=2023-01-01T00:00:00Z&to=2023-12-31T23:59:59Z" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

Reemplace YOUR_JWT_TOKEN con su token JWT real.

JavaScript

const searchDocuments = async (query, numResults = 5, from = null, to = null) => {
  const url = new URL('https://api.rememberizer.ai/api/v1/documents/search/');
  url.searchParams.append('q', query);
  url.searchParams.append('n', numResults);
  
  if (from) {
    url.searchParams.append('from', from);
  }
  
  if (to) {
    url.searchParams.append('to', to);
  }
  
  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_JWT_TOKEN'
    }
  });
  
  const data = await response.json();
  console.log(data);
};

searchDocuments('Cómo integrar Rememberizer con aplicaciones personalizadas', 5);

Reemplace YOUR_JWT_TOKEN con su token JWT real.

Python

import requests

def search_documents(query, num_results=5, from_date=None, to_date=None):
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN"
    }
    
    params = {
        "q": query,
        "n": num_results
    }
    
    if from_date:
        params["from"] = from_date
    
    if to_date:
        params["to"] = to_date
    
    response = requests.get(
        "https://api.rememberizer.ai/api/v1/documents/search/",
        headers=headers,
        params=params
    )
    
    data = response.json()
    print(data)

search_documents("Cómo integrar Rememberizer con aplicaciones personalizadas", 5)

Reemplace YOUR_JWT_TOKEN con su token JWT real.

Ruby

require 'net/http'
require 'uri'
require 'json'

def search_documents(query, num_results=5, from_date=nil, to_date=nil)
  uri = URI('https://api.rememberizer.ai/api/v1/documents/search/')
  params = {
    q: query,
    n: num_results
  }
  
  params[:from] = from_date if from_date
  params[:to] = to_date if to_date
  
  uri.query = URI.encode_www_form(params)
  
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = 'Bearer YOUR_JWT_TOKEN'
  
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  
  response = http.request(request)
  data = JSON.parse(response.body)
  puts data
end

search_documents("Cómo integrar Rememberizer con aplicaciones personalizadas", 5)

Reemplace YOUR_JWT_TOKEN con su token JWT real.

Parámetros de Consulta

Parámetro	Tipo	Descripción
q	cadena	Requerido. El texto de la consulta de búsqueda (hasta 400 palabras).
n	entero	Número de resultados a devolver. Predeterminado: 3. Utilice valores más altos (por ejemplo, 10) para obtener resultados más completos.
from	cadena	Inicio del rango de tiempo para los documentos a buscar, en formato ISO 8601.
to	cadena	Fin del rango de tiempo para los documentos a buscar, en formato ISO 8601.
prev_chunks	entero	Número de fragmentos anteriores a incluir para contexto. Predeterminado: 2.
next_chunks	entero	Número de fragmentos siguientes a incluir para contexto. Predeterminado: 2.

Formato de Respuesta

{
  "data_sources": [
    {
      "name": "Google Drive",
      "documents": 3
    },
    {
      "name": "Slack",
      "documents": 2
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 12345,
        "document_id": "1aBcD2efGhIjK3lMnOpQrStUvWxYz",
        "name": "Documentación de la API de Rememberizer.pdf",
        "type": "application/pdf",
        "path": "/Documents/Rememberizer/Documentación de la API.pdf",
        "url": "https://drive.google.com/file/d/1aBcD2efGhIjK3lMnOpQrStUvWxYz/view",
        "size": 250000,
        "created_time": "2023-05-10T14:30:00Z",
        "modified_time": "2023-06-15T09:45:00Z",
        "indexed_on": "2023-06-15T10:30:00Z",
        "integration": {
          "id": 101,
          "integration_type": "google_drive"
        }
      },
      "matched_content": "Para integrar Rememberizer con aplicaciones personalizadas, puedes usar el flujo de autenticación OAuth2 para autorizar tu aplicación a acceder a los datos de Rememberizer de un usuario. Una vez autorizado, tu aplicación puede usar las APIs de Rememberizer para buscar documentos, recuperar contenido y más.",
      "distance": 0.123
    },
    // ... más fragmentos coincidentes
  ],
  "message": "Búsqueda completada con éxito",
  "code": "success"
}

Consejos de Optimización de Búsqueda

Para Responder Preguntas

Al buscar una respuesta a una pregunta, intenta formular tu consulta como si fuera una respuesta ideal. Por ejemplo:

En lugar de: "¿Qué es la incrustación vectorial?" Intenta: "La incrustación vectorial es una técnica que convierte texto en vectores numéricos en un espacio de alta dimensión."

Para una comprensión más profunda de cómo funcionan las incrustaciones vectoriales y por qué este enfoque de búsqueda es efectivo, consulta ¿Qué son las Incrustaciones Vectoriales y las Bases de Datos Vectoriales?

Ajustando la Cantidad de Resultados

• Comienza con n=3 para resultados rápidos y de alta relevancia

• Aumenta a n=10 o más para información más completa

• Si la búsqueda devuelve información insuficiente, intenta aumentar el parámetro n

Filtrado Basado en el Tiempo

Utiliza los parámetros from y to para centrarte en documentos de períodos de tiempo específicos:

• Documentos recientes: Establece from en una fecha reciente

• Análisis histórico: Especifica un rango de fechas específico

• Excluyendo información desactualizada: Establece una fecha to apropiada

Operaciones por Lotes

Para manejar de manera eficiente grandes volúmenes de consultas de búsqueda, Rememberizer admite operaciones por lotes para optimizar el rendimiento y reducir la sobrecarga de llamadas a la API.

Búsqueda por Lotes

Python

import requests
import time
import json
from concurrent.futures import ThreadPoolExecutor

def batch_search_documents(queries, num_results=5, batch_size=10):
    """
    Realizar búsquedas por lotes con múltiples consultas
    
    Args:
        queries: Lista de cadenas de consulta de búsqueda
        num_results: Número de resultados a devolver por consulta
        batch_size: Número de consultas a procesar en paralelo
    
    Returns:
        Lista de resultados de búsqueda para cada consulta
    """
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN",
        "Content-Type": "application/json"
    }
    
    results = []
    
    # Procesar consultas en lotes
    for i in range(0, len(queries), batch_size):
        batch = queries[i:i+batch_size]
        
        # Crear un grupo de hilos para enviar solicitudes en paralelo
        with ThreadPoolExecutor(max_workers=batch_size) as executor:
            futures = []
            
            for query in batch:
                params = {
                    "q": query,
                    "n": num_results
                }
                
                future = executor.submit(
                    requests.get,
                    "https://api.rememberizer.ai/api/v1/documents/search/",
                    headers=headers,
                    params=params
                )
                futures.append(future)
            
            # Recoger resultados a medida que se completan
            for future in futures:
                response = future.result()
                results.append(response.json())
        
        # Limitación de tasa - pausa entre lotes para evitar la limitación de la API
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Ejemplo de uso
queries = [
    "Cómo usar OAuth con Rememberizer",
    "Opciones de configuración de la base de datos vectorial",
    "Mejores prácticas para la búsqueda semántica",
    # Agregar más consultas según sea necesario
]

results = batch_search_documents(queries, num_results=3, batch_size=5)

JavaScript

/**
 * Realizar búsquedas por lotes con múltiples consultas
 * 
 * @param {string[]} queries - Lista de cadenas de consulta de búsqueda
 * @param {number} numResults - Número de resultados a devolver por consulta
 * @param {number} batchSize - Número de consultas a procesar en paralelo
 * @param {number} delayBetweenBatches - Milisegundos a esperar entre lotes
 * @returns {Promise<Array>} - Lista de resultados de búsqueda para cada consulta
 */
async function batchSearchDocuments(queries, numResults = 5, batchSize = 10, delayBetweenBatches = 1000) {
  const results = [];
  
  // Procesar consultas en lotes
  for (let i = 0; i < queries.length; i += batchSize) {
    const batch = queries.slice(i, i + batchSize);
    
    // Crear un array de promesas para solicitudes concurrentes
    const batchPromises = batch.map(query => {
      const url = new URL('https://api.rememberizer.ai/api/v1/documents/search/');
      url.searchParams.append('q', query);
      url.searchParams.append('n', numResults);
      
      return fetch(url.toString(), {
        method: 'GET',
        headers: {
          'Authorization': 'Bearer YOUR_JWT_TOKEN'
        }
      }).then(response => response.json());
    });
    
    // Esperar a que todas las solicitudes en el lote se completen
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Limitación de tasa - pausa entre lotes para evitar la limitación de la API
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Ejemplo de uso
const queries = [
  "Cómo usar OAuth con Rememberizer",
  "Opciones de configuración de la base de datos vectorial",
  "Mejores prácticas para la búsqueda semántica",
  // Agregar más consultas según sea necesario
];

batchSearchDocuments(queries, 3, 5)
  .then(results => console.log(results))
  .catch(error => console.error('Error en la búsqueda por lotes:', error));

Ruby

require 'net/http'
require 'uri'
require 'json'
require 'concurrent'

# Realizar búsquedas por lotes con múltiples consultas
#
# @param queries [Array<String>] Lista de cadenas de consulta de búsqueda
# @param num_results [Integer] Número de resultados a devolver por consulta
# @param batch_size [Integer] Número de consultas a procesar en paralelo
# @param delay_between_batches [Float] Segundos a esperar entre lotes
# @return [Array] Lista de resultados de búsqueda para cada consulta
def batch_search_documents(queries, num_results = 5, batch_size = 10, delay_between_batches = 1.0)
  results = []
  
  # Procesar consultas en lotes
  queries.each_slice(batch_size).with_index do |batch, batch_index|
    # Crear un grupo de hilos para solicitudes concurrentes
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch.each do |query|
      futures << Concurrent::Future.execute(executor: pool) do
        uri = URI('https://api.rememberizer.ai/api/v1/documents/search/')
        params = {
          q: query,
          n: num_results
        }
        
        uri.query = URI.encode_www_form(params)
        
        request = Net::HTTP::Get.new(uri)
        request['Authorization'] = 'Bearer YOUR_JWT_TOKEN'
        
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true
        
        response = http.request(request)
        JSON.parse(response.body)
      end
    end
    
    # Recopilar resultados de todos los hilos
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Limitación de tasa - pausa entre lotes para evitar la limitación de la API
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Ejemplo de uso
queries = [
  "Cómo usar OAuth con Rememberizer",
  "Opciones de configuración de base de datos vectorial",
  "Mejores prácticas para la búsqueda semántica",
  # Agregar más consultas según sea necesario
]

results = batch_search_documents(queries, 3, 5)
puts results

Consideraciones de Rendimiento

Al implementar operaciones por lotes, considera estas mejores prácticas:

1. Tamaño Óptimo del Lote: Comienza con tamaños de lote de 5-10 consultas y ajusta según las características de rendimiento de tu aplicación.

2. Limitación de Tasa: Incluye retrasos entre lotes para prevenir la limitación de la API. Un buen punto de partida es 1 segundo entre lotes.

3. Manejo de Errores: Implementa un manejo de errores robusto para gestionar solicitudes fallidas dentro de los lotes.

4. Gestión de Recursos: Monitorea el uso de recursos del lado del cliente, particularmente con tamaños de lote grandes, para prevenir un consumo excesivo de memoria.

5. Procesamiento de Respuestas: Procesa los resultados de los lotes de manera asíncrona cuando sea posible para mejorar la experiencia del usuario.

Para aplicaciones de alto volumen, considera implementar un sistema de cola para gestionar grandes cantidades de solicitudes de búsqueda de manera eficiente.

Este endpoint proporciona potentes capacidades de búsqueda semántica en toda tu base de conocimientos. Utiliza incrustaciones vectoriales para encontrar contenido basado en el significado en lugar de coincidencias exactas de palabras clave.