Rememberizer Docs
Sign inSign upContact us
Português
Português
  • Por que Rememberizer?
  • Contexto
    • O que são Embeddings Vetoriais e Bancos de Dados Vetoriais?
    • Glossário
    • Terminologia Padronizada
  • Uso Pessoal
    • Introdução
      • Pesquise seu conhecimento
      • Acesso ao Filtro de Mementos
      • Conhecimento Comum
      • Gerencie seu conhecimento incorporado
  • Integrações
    • Aplicativo Rememberizer
    • Integração do Rememberizer com o Slack
    • Integração do Rememberizer com o Google Drive
    • Integração do Rememberizer com o Dropbox
    • Integração do Rememberizer com o Gmail
    • Integração do Rememberizer com a Memória
    • Servidores MCP do Rememberizer
    • Gerenciar aplicativos de terceiros
  • Recursos para Desenvolvedores
    • Visão Geral do Desenvolvedor
  • Opções de Integração
    • Registrando e usando Chaves de API
    • Registrando aplicativos Rememberizer
    • Autorizando aplicativos Rememberizer
    • Criando um Rememberizer GPT
    • Integração com LangChain
    • Armazenamentos de Vetores
    • Talk-to-Slack o Aplicativo Web de Exemplo
  • Integração Empresarial
    • Padrões de Integração Empresarial
  • Referência da API
    • Página Inicial da Documentação da API
    • Autenticação
  • APIs Principais
    • Pesquisar documentos por similaridade semântica
    • Recuperar documentos
    • Recuperar conteúdos de documentos
    • Recuperar conteúdo do Slack
    • Memorizar conteúdo para Rememberizer
  • Conta e Configuração
    • Recuperar detalhes da conta do usuário atual
    • Listar integrações de fontes de dados disponíveis
    • Mementos
    • Obter todo o conhecimento público adicionado
  • APIs de Armazenamento Vetorial
    • Documentação do Armazenamento Vetorial
    • Obter informações do armazenamento vetorial
    • Obter uma lista de documentos em um Armazenamento Vetorial
    • Obter informações do documento
    • Adicionar novo documento de texto a um Armazenamento Vetorial
    • Enviar arquivos para um Armazenamento Vetorial
    • Atualizar conteúdo de arquivo em um Armazenamento Vetorial
    • Remover um documento no Armazenamento Vetorial
    • Pesquisar documentos do Armazenamento Vetorial por similaridade semântica
  • Recursos Adicionais
    • Avisos
      • Termos de Uso
      • Política de Privacidade
      • B2B
        • Sobre o Reddit Agent
  • Lançamentos
    • Notas de Lançamento
  • Lançamentos de 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 Jan, 2025
  • Lançamentos de 2024
    • 27 de Dezembro de 2024
    • 20 de Dezembro de 2024
    • 13 de Dezembro de 2024
    • 6 de Dezembro de 2024
  • 29 de Nov, 2024
  • 22 de Nov, 2024
  • 15 de Nov, 2024
  • 8 de Nov, 2024
  • 1 de Nov, 2024
  • 25 de Out, 2024
  • 18 de Out, 2024
  • 11 de Out, 2024
  • 4 de Out, 2024
  • 27 de Set, 2024
  • 20 de Set, 2024
  • 13 de Set, 2024
  • 16 de Ago, 2024
  • 9 de Ago, 2024
  • 2 de Ago, 2024
  • 26 de Jul, 2024
  • 12 de Jul, 2024
  • 28 de Jun, 2024
  • 14 de Jun, 2024
  • 31 de Maio de 2024
  • 17 de Maio de 2024
  • 10 de Maio 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 Fev, 2024
  • 19 de Fev, 2024
  • 12 de Fev, 2024
  • 5 de Fev, 2024
  • 29 de Jan, 2024
  • 22 de Jan, 2024
  • 15 de Jan, 2024
  • Documentação LLM
    • Documentação LLM Ready do Rememberizer
Powered by GitBook
On this page
  1. APIs Principais

Pesquisar documentos por similaridade semântica

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

PreviousAutenticaçãoNextRecuperar documentos

Last updated 23 days ago

Exemplo de Solicitações

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.

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.

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.

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

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

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

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?
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-22T06:54:17.721Z",
        "modified_time": "2025-05-22T06:54:17.721Z",
        "indexed_on": "2025-05-22T06:54:17.721Z",
        "integration": {
          "id": 1,
          "integration_type": "text"
        }
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}
  • GET/documents/search/
  • Exemplo de Solicitações
  • Parâmetros da Consulta
  • Formato de Resposta
  • Dicas de Otimização de Busca
  • Para Respostas a Perguntas
  • Ajustando a Contagem de Resultados
  • Filtragem Baseada em Tempo
  • Operações em Lote
  • Pesquisa em Lote
  • Considerações de Desempenho