Pesquisar documentos por similaridade semântica

Endpoint de busca semântica com capacidades de processamento em lote

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-05-18T11:25:27.178Z",
        "modified_time": "2025-05-18T11:25:27.178Z",
        "indexed_on": "2025-05-18T11:25:27.178Z",
        "integration": {
          "id": 1,
          "integration_type": "text"
        }
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}

Exemplo de Solicitações

cURL

curl -X GET \
  "https://api.rememberizer.ai/api/v1/documents/search/?q=Como%20integrar%20o%20Rememberizer%20com%20aplicações%20personalizadas&n=5&from=2023-01-01T00:00:00Z&to=2023-12-31T23:59:59Z" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

Substitua YOUR_JWT_TOKEN pelo seu 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('Como integrar o Rememberizer com aplicações personalizadas', 5);

Substitua YOUR_JWT_TOKEN pelo seu 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("Como integrar o Rememberizer com aplicações personalizadas", 5)

Substitua YOUR_JWT_TOKEN pelo seu 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("Como integrar o Rememberizer com aplicações personalizadas", 5)

Substitua YOUR_JWT_TOKEN pelo seu token JWT real.

Parâmetros da Consulta

Parâmetro	Tipo	Descrição
q	string	Obrigatório. O texto da consulta de pesquisa (até 400 palavras).
n	integer	Número de resultados a retornar. Padrão: 3. Use valores mais altos (por exemplo, 10) para resultados mais abrangentes.
from	string	Início do intervalo de tempo para os documentos a serem pesquisados, no formato ISO 8601.
to	string	Fim do intervalo de tempo para os documentos a serem pesquisados, no formato ISO 8601.
prev_chunks	integer	Número de partes anteriores a incluir para contexto. Padrão: 2.
next_chunks	integer	Número de partes seguintes a incluir para contexto. Padrão: 2.

Formato de Resposta

{
  "data_sources": [
    {
      "name": "Google Drive",
      "documents": 3
    },
    {
      "name": "Slack",
      "documents": 2
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 12345,
        "document_id": "1aBcD2efGhIjK3lMnOpQrStUvWxYz",
        "name": "Documentação da API Rememberizer.pdf",
        "type": "application/pdf",
        "path": "/Documents/Rememberizer/Documentação da 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 o Rememberizer com aplicativos personalizados, você pode usar o fluxo de autenticação OAuth2 para autorizar seu aplicativo a acessar os dados do Rememberizer de um usuário. Uma vez autorizado, seu aplicativo pode usar as APIs do Rememberizer para buscar documentos, recuperar conteúdo e mais.",
      "distance": 0.123
    },
    // ... mais partes correspondentes
  ],
  "message": "Busca concluída com sucesso",
  "code": "success"
}

Dicas de Otimização de Busca

Para Respostas a Perguntas

Ao procurar uma resposta para uma pergunta, tente formular sua consulta como se fosse uma resposta ideal. Por exemplo:

Em vez de: "O que é incorporação vetorial?" Tente: "Incorporação vetorial é uma técnica que converte texto em vetores numéricos em um espaço de alta dimensão."

Para uma compreensão mais profunda de como as incorporações vetoriais funcionam e por que essa abordagem de busca é eficaz, veja O que são Incorporações Vetoriais e Bancos de Dados Vetoriais?

Ajustando a Contagem de Resultados

• Comece com n=3 para resultados rápidos e de alta relevância

• Aumente para n=10 ou mais para informações mais abrangentes

• Se a pesquisa retornar informações insuficientes, tente aumentar o parâmetro n

Filtragem Baseada em Tempo

Use os parâmetros from e to para focar em documentos de períodos específicos:

• Documentos recentes: Defina from para uma data recente

• Análise histórica: Especifique um intervalo de datas específico

• Excluindo informações desatualizadas: Defina uma data to apropriada

Operações em Lote

Para lidar de forma eficiente com grandes volumes de consultas de pesquisa, o Rememberizer suporta operações em lote para otimizar o desempenho e reduzir a sobrecarga de chamadas à API.

Pesquisa em Lote

Python

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

def batch_search_documents(queries, num_results=5, batch_size=10):
    """
    Realiza pesquisas em lote com várias consultas
    
    Args:
        queries: Lista de strings de consulta de pesquisa
        num_results: Número de resultados a retornar por consulta
        batch_size: Número de consultas a processar em paralelo
    
    Returns:
        Lista de resultados de pesquisa para cada consulta
    """
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN",
        "Content-Type": "application/json"
    }
    
    results = []
    
    # Processar consultas em lotes
    for i in range(0, len(queries), batch_size):
        batch = queries[i:i+batch_size]
        
        # Criar um pool de threads para enviar solicitações em 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)
            
            # Coletar resultados à medida que são concluídos
            for future in futures:
                response = future.result()
                results.append(response.json())
        
        # Limitação de taxa - pausar entre lotes para evitar estrangulamento da API
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Exemplo de uso
queries = [
    "Como usar OAuth com Rememberizer",
    "Opções de configuração do banco de dados vetorial",
    "Melhores práticas para busca semântica",
    # Adicione mais consultas conforme necessário
]

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

JavaScript

/**
 * Realiza buscas em lote com várias consultas
 * 
 * @param {string[]} queries - Lista de strings de consulta de busca
 * @param {number} numResults - Número de resultados a serem retornados por consulta
 * @param {number} batchSize - Número de consultas a serem processadas em paralelo
 * @param {number} delayBetweenBatches - Milissegundos a esperar entre os lotes
 * @returns {Promise<Array>} - Lista de resultados de busca para cada consulta
 */
async function batchSearchDocuments(queries, numResults = 5, batchSize = 10, delayBetweenBatches = 1000) {
  const results = [];
  
  // Processar consultas em lotes
  for (let i = 0; i < queries.length; i += batchSize) {
    const batch = queries.slice(i, i + batchSize);
    
    // Criar um array de promessas para requisições concorrentes
    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());
    });
    
    // Aguardar todas as requisições no lote serem concluídas
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Limitação de taxa - pausar entre lotes para evitar limitação da API
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Exemplo de uso
const queries = [
  "Como usar OAuth com Rememberizer",
  "Opções de configuração do banco de dados vetorial",
  "Melhores práticas para busca semântica",
  // Adicione mais consultas conforme necessário
];

batchSearchDocuments(queries, 3, 5)
  .then(results => console.log(results))
  .catch(error => console.error('Erro na busca em lote:', error));

Ruby

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

# Realizar buscas em lote com múltiplas consultas
#
# @param queries [Array<String>] Lista de strings de consulta de pesquisa
# @param num_results [Integer] Número de resultados a retornar por consulta
# @param batch_size [Integer] Número de consultas a serem processadas em paralelo
# @param delay_between_batches [Float] Segundos a esperar entre os lotes
# @return [Array] Lista de resultados de busca para cada consulta
def batch_search_documents(queries, num_results = 5, batch_size = 10, delay_between_batches = 1.0)
  results = []
  
  # Processar consultas em lotes
  queries.each_slice(batch_size).with_index do |batch, batch_index|
    # Criar um pool de threads para requisições concorrentes
    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
    
    # Coletar resultados de todas as threads
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Limitação de taxa - pausar entre lotes para evitar estrangulamento da API
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Exemplo de uso
queries = [
  "Como usar OAuth com Rememberizer",
  "Opções de configuração do banco de dados vetorial",
  "Melhores práticas para busca semântica",
  # Adicione mais consultas conforme necessário
]

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

Considerações de Desempenho

Ao implementar operações em lote, considere estas melhores práticas:

1. Tamanho de Lote Ideal: Comece com tamanhos de lote de 5-10 consultas e ajuste com base nas características de desempenho do seu aplicativo.

2. Limitação de Taxa: Inclua atrasos entre os lotes para evitar a limitação da API. Um bom ponto de partida é 1 segundo entre os lotes.

3. Tratamento de Erros: Implemente um tratamento de erros robusto para gerenciar solicitações falhadas dentro dos lotes.

4. Gerenciamento de Recursos: Monitore o uso de recursos do lado do cliente, particularmente com tamanhos de lote grandes, para evitar consumo excessivo de memória.

5. Processamento de Respostas: Processar os resultados do lote de forma assíncrona quando possível para melhorar a experiência do usuário.

Para aplicativos de alto volume, considere implementar um sistema de fila para gerenciar grandes números de solicitações de busca de forma eficiente.

Este endpoint fornece poderosas capacidades de busca semântica em toda a sua base de conhecimento. Ele utiliza embeddings vetoriais para encontrar conteúdo com base no significado, em vez de correspondências exatas de palavras-chave.