# Pesquisar documentos por similaridade semântica

{% openapi src="/files/7wfxJNjaZYJgvBWvXvoQ" path="/documents/search/" method="get" %}
[rememberizer\_openapi.yml](https://606058861-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FDrEOD8oYxrWDlC9WhJ3K%2Fuploads%2Fgit-blob-77b6137eeb641262ec8e531c78123c02b825b865%2Frememberizer_openapi.yml?alt=media\&token=85552d2b-b485-42dc-a027-aa2441b8ca9f)
{% endopenapi %}

## Exemplo de Solicitações

{% tabs %}
{% tab title="cURL" %}

```bash
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"
```

{% hint style="info" %}
Substitua `YOUR_JWT_TOKEN` pelo seu token JWT real.
{% endhint %}
{% endtab %}

{% tab title="JavaScript" %}

```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);
```

{% hint style="info" %}
Substitua `YOUR_JWT_TOKEN` pelo seu token JWT real.
{% endhint %}
{% endtab %}

{% tab title="Python" %}

```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)
```

{% hint style="info" %}
Substitua `YOUR_JWT_TOKEN` pelo seu token JWT real.
{% endhint %}
{% endtab %}

{% tab title="Ruby" %}

```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)
```

{% hint style="info" %}
Substitua `YOUR_JWT_TOKEN` pelo seu token JWT real.
{% endhint %}
{% endtab %}
{% endtabs %}

## 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

```json
{
  "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."

{% hint style="info" %}
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?](/pt/background/what-are-vector-embeddings-and-vector-databases.md)
{% endhint %}

### 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

{% tabs %}
{% tab title="Python" %}

```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)
```

{% endtab %}

{% tab title="JavaScript" %}

```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));
```

{% endtab %}

{% tab title="Ruby" %}

```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
```

{% endtab %}
{% endtabs %}

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/pt/recursos-para-desenvolvedores/api-docs/search-for-documents-by-semantic-similarity.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.