Rememberizer Docs
Iniciar sesiónInscribirseContáctenos
Español
Español
  • ¿Por qué Rememberizer?
  • Antecedentes
    • ¿Qué son los Embeddings Vectoriales y las Bases de Datos Vectoriales?
    • Glosario
    • Terminología Estandarizada
  • Uso Personal
    • Comenzando
      • Buscar tu conocimiento
      • Acceso al Filtro de Mementos
      • Conocimiento Común
      • Gestiona tu conocimiento incrustado
  • Integraciones
    • Aplicación Rememberizer
    • Integración de Rememberizer con Slack
    • Integración de Rememberizer con Google Drive
    • Integración de Rememberizer con Dropbox
    • Integración de Rememberizer con Gmail
    • Integración de Rememberizer con Memory
    • Servidores MCP de Rememberizer
    • Gestionar aplicaciones de terceros
  • Recursos para Desarrolladores
    • Descripción General del Desarrollador
  • Opciones de Integración
    • Registrar y usar claves API
    • Registrar aplicaciones de Rememberizer
    • Autorizar aplicaciones de Rememberizer
    • Crear un Rememberizer GPT
    • Integración de LangChain
    • Almacenes de Vectores
    • Hablar con Slack la Aplicación Web de Ejemplo
  • Integración Empresarial
    • Patrones de Integración Empresarial
  • Referencia de la API
    • Inicio de la Documentación de la API
    • Autenticación
  • APIs principales
    • Buscar documentos por similitud semántica
    • Recuperar documentos
    • Recuperar contenidos de documentos
    • Recuperar contenido de Slack
    • Memorizar contenido en Rememberizer
  • Cuenta y Configuración
    • Recuperar detalles de la cuenta de usuario actual
    • Listar integraciones de fuentes de datos disponibles
    • Mementos
    • Obtener todo el conocimiento público agregado
  • APIs de Almacenamiento de Vectores
    • Documentación del Almacenamiento de Vectores
    • Obtener información del almacenamiento de vectores
    • Obtener una lista de documentos en un Almacenamiento de Vectores
    • Obtener información del documento
    • Agregar un nuevo documento de texto a un Almacenamiento de Vectores
    • Subir archivos a un Almacenamiento de Vectores
    • Actualizar el contenido del archivo en un Almacenamiento de Vectores
    • Eliminar un documento en el Almacenamiento de Vectores
    • Buscar documentos del Almacenamiento de Vectores por similitud semántica
  • Recursos Adicionales
    • Avisos
      • Términos de Uso
      • Política de Privacidad
      • B2B
        • Acerca de Reddit Agent
  • Lanzamientos
    • Notas de la versión Inicio
  • Lanzamientos 2025
    • 25 de abr, 2025
    • 18 de abr, 2025
    • 11 de abr, 2025
    • 4 de abr, 2025
    • 28 de mar, 2025
    • 21 de mar, 2025
    • 14 de mar, 2025
    • 17 de ene, 2025
  • Lanzamientos 2024
    • 27 de diciembre de 2024
    • 20 de diciembre de 2024
    • 13 de diciembre de 2024
    • 6 de diciembre de 2024
  • 29 de Noviembre de 2024
  • 22 de Noviembre de 2024
  • 15 de Noviembre de 2024
  • 8 de Noviembre de 2024
  • 1 de Noviembre de 2024
  • 25 de oct, 2024
  • 18 de oct, 2024
  • 11 de oct, 2024
  • 4 de oct, 2024
  • 27 de sep, 2024
  • 20 de sep, 2024
  • 13 de sep, 2024
  • 16 de agosto de 2024
  • 9 de agosto de 2024
  • 2 de agosto de 2024
  • 26 de julio de 2024
  • 12 de julio de 2024
  • 28 de jun, 2024
  • 14 de jun, 2024
  • 31 de mayo de 2024
  • 17 de mayo de 2024
  • 10 de mayo de 2024
  • 26 de abr, 2024
  • 19 de abr, 2024
  • 12 de abr, 2024
  • 5 de abr, 2024
  • 25 de mar, 2024
  • 18 de mar, 2024
  • 11 de mar, 2024
  • 4 de mar, 2024
  • 26 de Febrero de 2024
  • 19 de Febrero de 2024
  • 12 de Febrero de 2024
  • 5 de Febrero de 2024
  • 29 de enero de 2024
  • 22 de enero de 2024
  • 15 de enero de 2024
  • Documentación LLM
    • Documentación Lista para LLM de Rememberizer
Powered by GitBook
On this page
  1. APIs principales

Buscar documentos por similitud semántica

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

PreviousAutenticaciónNextRecuperar documentos

Last updated 22 days ago

Ejemplos de Solicitudes

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.

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.

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.

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."

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

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)
/**
 * 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));
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.

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?
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
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-05-21T08:31:44.330Z",
        "modified_time": "2025-05-21T08:31:44.330Z",
        "indexed_on": "2025-05-21T08:31:44.330Z",
        "integration": {
          "id": 1,
          "integration_type": "text"
        }
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}
  • GET/documents/search/
  • Ejemplos de Solicitudes
  • Parámetros de Consulta
  • Formato de Respuesta
  • Consejos de Optimización de Búsqueda
  • Para Responder Preguntas
  • Ajustando la Cantidad de Resultados
  • Filtrado Basado en el Tiempo
  • Operaciones por Lotes
  • Búsqueda por Lotes
  • Consideraciones de Rendimiento