Rechercher des documents par similarité sémantique

Point de terminaison de recherche sémantique avec capacités de traitement par lots

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

/documents/search/

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-11-07T17:32:42.969Z",
        "modified_time": "2025-11-07T17:32:42.969Z",
        "indexed_on": "2025-11-07T17:32:42.969Z",
        "integration": {
          "id": 1,
          "integration_type": "text"
        }
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}

Exemples de Requêtes

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"

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

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)

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)

Remplacez YOUR_JWT_TOKEN par votre véritable jeton JWT.

Paramètres de requête

Paramètre

Type

Description

chaîne

Requis. Le texte de la requête de recherche (jusqu'à 400 mots).

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.

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

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

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.

PreviousRécupérer le contenu de Slack NextAPIs de magasin de vecteurs

Last updated 7 hours ago