# Rechercher des documents par similarité sémantique

{% openapi src="/files/k0wV9YEEppPnffcGeVUk" path="/documents/search/" method="get" %}
[rememberizer\_openapi.yml](https://3811618827-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FwduaTA5Sz3nf9aH5k1S6%2Fuploads%2Fgit-blob-77b6137eeb641262ec8e531c78123c02b825b865%2Frememberizer_openapi.yml?alt=media\&token=9d0098e1-f392-4761-be64-ff6f2caad99e)
{% endopenapi %}

## Exemples de Requêtes

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

```bash
curl -X GET \
  "https://api.rememberizer.ai/api/v1/documents/search/?q=Comment%20intégrer%20Rememberizer%20avec%20des%20applications%20personnalisées&n=5&from=2023-01-01T00:00:00Z&to=2023-12-31T23:59:59Z" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

{% hint style="info" %}
Remplacez `YOUR_JWT_TOKEN` par votre véritable jeton JWT.
{% 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('Comment intégrer Rememberizer avec des applications personnalisées', 5);
```

{% hint style="info" %}
Remplacez `YOUR_JWT_TOKEN` par votre véritable jeton JWT.
{% 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("Comment intégrer Rememberizer avec des applications personnalisées", 5)
```

{% hint style="info" %}
Remplacez `YOUR_JWT_TOKEN` par votre véritable jeton JWT.
{% 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("Comment intégrer Rememberizer avec des applications personnalisées", 5)
```

{% hint style="info" %}
Remplacez `YOUR_JWT_TOKEN` par votre véritable jeton JWT.
{% endhint %}
{% endtab %}
{% endtabs %}

## Paramètres de requête

| Paramètre    | Type   | Description                                                                                                                            |
| ------------ | ------ | -------------------------------------------------------------------------------------------------------------------------------------- |
| q            | chaîne | **Requis.** Le texte de la requête de recherche (jusqu'à 400 mots).                                                                    |
| n            | entier | Nombre de résultats à retourner. Par défaut : 3. Utilisez des valeurs plus élevées (par exemple, 10) pour des résultats plus complets. |
| from         | chaîne | Début de la plage de temps pour les documents à rechercher, au format ISO 8601.                                                        |
| to           | chaîne | Fin de la plage de temps pour les documents à rechercher, au format ISO 8601.                                                          |
| prev\_chunks | entier | Nombre de morceaux précédents à inclure pour le contexte. Par défaut : 2.                                                              |
| next\_chunks | entier | Nombre de morceaux suivants à inclure pour le contexte. Par défaut : 2.                                                                |

## Format de Réponse

```json
{
  "data_sources": [
    {
      "name": "Google Drive",
      "documents": 3
    },
    {
      "name": "Slack",
      "documents": 2
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 12345,
        "document_id": "1aBcD2efGhIjK3lMnOpQrStUvWxYz",
        "name": "Documentation de l'API Rememberizer.pdf",
        "type": "application/pdf",
        "path": "/Documents/Rememberizer/Documentation de l'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": "Pour intégrer Rememberizer avec des applications personnalisées, vous pouvez utiliser le flux d'authentification OAuth2 pour autoriser votre application à accéder aux données Rememberizer d'un utilisateur. Une fois autorisée, votre application peut utiliser les API Rememberizer pour rechercher des documents, récupérer du contenu, et plus encore.",
      "distance": 0.123
    },
    // ... plus de morceaux correspondants
  ],
  "message": "Recherche terminée avec succès",
  "code": "success"
}
```

## Conseils d'Optimisation de Recherche

### Pour la réponse à des questions

Lorsque vous recherchez une réponse à une question, essayez de formuler votre requête comme si c'était une réponse idéale. Par exemple :

Au lieu de : "Qu'est-ce que l'incorporation vectorielle ?" Essayez : "L'incorporation vectorielle est une technique qui convertit le texte en vecteurs numériques dans un espace à haute dimension."

{% hint style="info" %}
Pour une compréhension plus approfondie de la façon dont fonctionnent les incorporations vectorielles et pourquoi cette approche de recherche est efficace, consultez [Qu'est-ce que les incorporations vectorielles et les bases de données vectorielles ?](/fr/background/what-are-vector-embeddings-and-vector-databases.md)
{% endhint %}

### Ajustement du Nombre de Résultats

* Commencez avec `n=3` pour des résultats rapides et de haute pertinence
* Augmentez à `n=10` ou plus pour des informations plus complètes
* Si la recherche renvoie des informations insuffisantes, essayez d'augmenter le paramètre `n`

### Filtrage par Date

Utilisez les paramètres `from` et `to` pour vous concentrer sur des documents provenant de périodes spécifiques :

* Documents récents : Définissez `from` à une date récente
* Analyse historique : Spécifiez une plage de dates spécifique
* Exclusion des informations obsolètes : Définissez une date `to` appropriée

## Opérations par lots

Pour gérer efficacement de grands volumes de requêtes de recherche, Rememberizer prend en charge les opérations par lots pour optimiser les performances et réduire la surcharge des appels API.

### Recherche par lot

{% 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):
    """
    Effectuer des recherches par lot avec plusieurs requêtes
    
    Args:
        queries: Liste de chaînes de requêtes de recherche
        num_results: Nombre de résultats à retourner par requête
        batch_size: Nombre de requêtes à traiter en parallèle
    
    Returns:
        Liste des résultats de recherche pour chaque requête
    """
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN",
        "Content-Type": "application/json"
    }
    
    results = []
    
    # Traiter les requêtes par lots
    for i in range(0, len(queries), batch_size):
        batch = queries[i:i+batch_size]
        
        # Créer un pool de threads pour envoyer des requêtes en parallèle
        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)
            
            # Collecter les résultats au fur et à mesure qu'ils se terminent
            for future in futures:
                response = future.result()
                results.append(response.json())
        
        # Limitation de débit - pause entre les lots pour éviter le throttling de l'API
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Exemple d'utilisation
queries = [
    "Comment utiliser OAuth avec Rememberizer",
    "Options de configuration de la base de données vectorielle",
    "Meilleures pratiques pour la recherche sémantique",
    # Ajouter plus de requêtes si nécessaire
]

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

{% endtab %}

{% tab title="JavaScript" %}

```javascript
/**
 * Effectuer des recherches par lots avec plusieurs requêtes
 * 
 * @param {string[]} queries - Liste des chaînes de requêtes de recherche
 * @param {number} numResults - Nombre de résultats à retourner par requête
 * @param {number} batchSize - Nombre de requêtes à traiter en parallèle
 * @param {number} delayBetweenBatches - Millisecondes à attendre entre les lots
 * @returns {Promise<Array>} - Liste des résultats de recherche pour chaque requête
 */
async function batchSearchDocuments(queries, numResults = 5, batchSize = 10, delayBetweenBatches = 1000) {
  const results = [];
  
  // Traiter les requêtes par lots
  for (let i = 0; i < queries.length; i += batchSize) {
    const batch = queries.slice(i, i + batchSize);
    
    // Créer un tableau de promesses pour des requêtes 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());
    });
    
    // Attendre que toutes les requêtes du lot soient terminées
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Limitation de débit - pause entre les lots pour éviter le throttling de l'API
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Exemple d'utilisation
const queries = [
  "Comment utiliser OAuth avec Rememberizer",
  "Options de configuration de la base de données vectorielle",
  "Meilleures pratiques pour la recherche sémantique",
  // Ajouter plus de requêtes si nécessaire
];

batchSearchDocuments(queries, 3, 5)
  .then(results => console.log(results))
  .catch(error => console.error('Erreur dans la recherche par lots:', error));
```

{% endtab %}

{% tab title="Ruby" %}

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

# Effectuer des recherches par lots avec plusieurs requêtes
#
# @param queries [Array<String>] Liste des chaînes de requêtes de recherche
# @param num_results [Integer] Nombre de résultats à retourner par requête
# @param batch_size [Integer] Nombre de requêtes à traiter en parallèle
# @param delay_between_batches [Float] Secondes à attendre entre les lots
# @return [Array] Liste des résultats de recherche pour chaque requête
def batch_search_documents(queries, num_results = 5, batch_size = 10, delay_between_batches = 1.0)
  results = []
  
  # Traiter les requêtes par lots
  queries.each_slice(batch_size).with_index do |batch, batch_index|
    # Créer un pool de threads pour des requêtes 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
    
    # Collecter les résultats de tous les threads
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Limitation de débit - pause entre les lots pour éviter le throttling de l'API
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Exemple d'utilisation
queries = [
  "Comment utiliser OAuth avec Rememberizer",
  "Options de configuration de la base de données vectorielle",
  "Meilleures pratiques pour la recherche sémantique",
  # Ajouter plus de requêtes si nécessaire
]

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

{% endtab %}
{% endtabs %}

### Considérations de Performance

Lors de l'implémentation d'opérations par lots, considérez ces meilleures pratiques :

1. **Taille de Lot Optimale** : Commencez avec des tailles de lot de 5 à 10 requêtes et ajustez en fonction des caractéristiques de performance de votre application.
2. **Limitation de Taux** : Incluez des délais entre les lots pour éviter le throttling de l'API. Un bon point de départ est de 1 seconde entre les lots.
3. **Gestion des Erreurs** : Implémentez une gestion des erreurs robuste pour gérer les requêtes échouées au sein des lots.
4. **Gestion des Ressources** : Surveillez l'utilisation des ressources côté client, en particulier avec de grandes tailles de lot, pour éviter une consommation excessive de mémoire.
5. **Traitement des Réponses** : Traitez les résultats des lots de manière asynchrone lorsque cela est possible pour améliorer l'expérience utilisateur.

Pour les applications à fort volume, envisagez de mettre en œuvre un système de file d'attente pour gérer efficacement un grand nombre de requêtes de recherche.

Ce point de terminaison offre de puissantes capacités de recherche sémantique à travers l'ensemble de votre base de connaissances. Il utilise des embeddings vectoriels pour trouver du contenu basé sur le sens plutôt que sur des correspondances exactes de mots-clés.


---

# 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/fr/ressources-pour-les-developpeurs/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.