Rechercher des documents par similarité sémantique¶

`GET /documents/search/`¶

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.

Parameter	In	Type	Description
`q`	query	string	Up to 400 words sentence for which you wish to find semantically similar chunks of knowledge.
`n`	query	integer	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.
`from`	query	string	Start of the time range for documents to be searched, in ISO 8601 format.
`to`	query	string	End of the time range for documents to be searched, in ISO 8601 format.

Responses

200 — Successful retrieval of documents
400 — Bad request
401 — Unauthorized
404 — Not found
500 — Internal server error

Exemples de Requêtes¶

cURLJavaScriptPythonRuby

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"

Info

Remplacez YOUR_JWT_TOKEN par votre véritable jeton JWT.

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

Info

Remplacez YOUR_JWT_TOKEN par votre véritable jeton JWT.

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)

Info

Remplacez YOUR_JWT_TOKEN par votre véritable jeton JWT.

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)

Info

Remplacez YOUR_JWT_TOKEN par votre véritable jeton JWT.

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¶

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

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 ?

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¶

PythonJavaScriptRuby

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)

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

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

Considérations de Performance¶

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

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.
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.
Gestion des Erreurs : Implémentez une gestion des erreurs robuste pour gérer les requêtes échouées au sein des lots.
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.
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.

Rechercher des documents par similarité sémantique¶

GET /documents/search/¶

Exemples de Requêtes¶

Paramètres de requête¶

Format de Réponse¶

Conseils d'Optimisation de Recherche¶

Pour la réponse à des questions¶

Ajustement du Nombre de Résultats¶

Filtrage par Date¶

Opérations par lots¶

Recherche par lot¶

Considérations de Performance¶

`GET /documents/search/`¶