Rechercher des documents de stockage vectoriel par similarité sémantique

Rechercher des documents dans le magasin de vecteurs avec similarité sémantique et opérations par lots

get

Initiate a search operation with a query text and receive most semantically similar responses from the vector store.

Path parameters

vector-store-idstringRequired

The ID of the vector store.

Query parameters

qstringRequired

The search query text.

nintegerOptional

Number of chunks to return.

tnumberOptional

Matching threshold.

prev_chunksintegerOptional

Number of chunks before the matched chunk to include.

next_chunksintegerOptional

Number of chunks after the matched chunk to include.

Header parameters

x-api-keystringRequired

The API key for authentication.

Responses

200

Search results retrieved successfully.

application/json

get

HTTPcURLJavaScriptPython

GET /api/v1/vector-stores/{vector-store-id}/documents/search HTTP/1.1
Host: api.rememberizer.ai
x-api-key: text
Accept: */*

200

Search results retrieved successfully.

{
  "vector_store": {
    "id": "text",
    "name": "text"
  },
  "matched_chunks": [
    {
      "document": {
        "id": 1,
        "name": "text",
        "type": "text",
        "size": 1,
        "indexed_on": "2025-05-23T17:12:54.145Z",
        "vector_store": "text",
        "created": "2025-05-23T17:12:54.145Z",
        "modified": "2025-05-23T17:12:54.145Z"
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}

Exemples de Requêtes

cURL

curl -X GET \
  "https://api.rememberizer.ai/api/v1/vector-stores/vs_abc123/documents/search?q=Comment%20intégrer%20notre%20produit%20avec%20des%20systèmes%20tiers&n=5&prev_chunks=1&next_chunks=1" \
  -H "x-api-key: VOTRE_CLE_API"

Remplacez VOTRE_CLE_API par votre véritable clé API de Vector Store et vs_abc123 par votre ID de Vector Store.

JavaScript

const searchVectorStore = async (vectorStoreId, query, numResults = 5, prevChunks = 1, nextChunks = 1) => {
  const url = new URL(`https://api.rememberizer.ai/api/v1/vector-stores/${vectorStoreId}/documents/search`);
  url.searchParams.append('q', query);
  url.searchParams.append('n', numResults);
  url.searchParams.append('prev_chunks', prevChunks);
  url.searchParams.append('next_chunks', nextChunks);
  
  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      'x-api-key': 'VOTRE_CLE_API'
    }
  });
  
  const data = await response.json();
  console.log(data);
};

searchVectorStore(
  'vs_abc123',
  'Comment intégrer notre produit avec des systèmes tiers',
  5,
  1,
  1
);

Remplacez VOTRE_CLE_API par votre véritable clé API de Vector Store et vs_abc123 par votre ID de Vector Store.

Python

import requests

def search_vector_store(vector_store_id, query, num_results=5, prev_chunks=1, next_chunks=1):
    headers = {
        "x-api-key": "VOTRE_CLE_API"
    }
    
    params = {
        "q": query,
        "n": num_results,
        "prev_chunks": prev_chunks,
        "next_chunks": next_chunks
    }
    
    response = requests.get(
        f"https://api.rememberizer.ai/api/v1/vector-stores/{vector_store_id}/documents/search",
        headers=headers,
        params=params
    )
    
    data = response.json()
    print(data)

search_vector_store(
    'vs_abc123',
    'Comment intégrer notre produit avec des systèmes tiers',
    5,
    1,
    1
)

Remplacez VOTRE_CLE_API par votre véritable clé API de Vector Store et vs_abc123 par votre ID de Vector Store.

Ruby

require 'net/http'
require 'uri'
require 'json'

def search_vector_store(vector_store_id, query, num_results=5, prev_chunks=1, next_chunks=1)
  uri = URI("https://api.rememberizer.ai/api/v1/vector-stores/#{vector_store_id}/documents/search")
  params = {
    q: query,
    n: num_results,
    prev_chunks: prev_chunks,
    next_chunks: next_chunks
  }
  
  uri.query = URI.encode_www_form(params)
  
  request = Net::HTTP::Get.new(uri)
  request['x-api-key'] = 'VOTRE_CLE_API'
  
  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_vector_store(
  'vs_abc123',
  'Comment intégrer notre produit avec des systèmes tiers',
  5,
  1,
  1
)

Remplacez VOTRE_CLE_API par votre véritable clé API de Vector Store et vs_abc123 par votre ID de Vector Store.

Paramètres de chemin

Paramètre	Type	Description
vector-store-id	string	Requis. L'ID du magasin de vecteurs dans lequel rechercher.

Paramètres de requête

Paramètre	Type	Description
q	chaîne	Requis. Le texte de la requête de recherche.
n	entier	Nombre de résultats à retourner. Par défaut : 10.
t	nombre	Seuil de correspondance. Par défaut : 0.7.
prev_chunks	entier	Nombre de morceaux avant le morceau correspondant à inclure. Par défaut : 0.
next_chunks	entier	Nombre de morceaux après le morceau correspondant à inclure. Par défaut : 0.

Format de Réponse

{
  "vector_store": {
    "id": "vs_abc123",
    "name": "Documentation du Produit"
  },
  "matched_chunks": [
    {
      "document": {
        "id": 1234,
        "name": "Guide d'Intégration.pdf",
        "type": "application/pdf",
        "size": 250000,
        "indexed_on": "2023-06-15T10:30:00Z",
        "vector_store": "vs_abc123",
        "created": "2023-06-15T10:15:00Z",
        "modified": "2023-06-15T10:30:00Z"
      },
      "matched_content": "Notre produit offre plusieurs options d'intégration pour les systèmes tiers. La méthode principale est via notre API RESTful, qui prend en charge l'authentification OAuth2. De plus, vous pouvez utiliser notre SDK disponible en Python, JavaScript et Java.",
      "distance": 0.123
    },
    // ... plus de morceaux correspondants
  ]
}

Authentification

Ce point de terminaison nécessite une authentification à l'aide d'une clé API dans l'en-tête x-api-key.

Réponses d'erreur

Code d'état	Description
400	Mauvaise requête - Paramètres requis manquants ou format invalide
401	Non autorisé - Clé API invalide ou manquante
404	Non trouvé - Magasin de vecteurs non trouvé
500	Erreur interne du serveur

Conseils d'Optimisation de Recherche

Fenêtres de Contexte

Utilisez les paramètres prev_chunks et next_chunks pour contrôler la quantité de contexte incluse avec chaque correspondance :

• Réglez les deux sur 0 pour des correspondances précises sans contexte

• Réglez les deux sur 1-2 pour des correspondances avec un contexte minimal

• Réglez les deux sur 3-5 pour des correspondances avec un contexte substantiel

Seuil de Correspondance

Le paramètre t contrôle la rigueur avec laquelle les correspondances sont filtrées :

• Des valeurs plus élevées (par exemple, 0.9) ne retournent que des correspondances très proches

• Des valeurs plus basses (par exemple, 0.5) retournent plus de correspondances avec une plus grande variété

• La valeur par défaut (0.7) offre une approche équilibrée

Opérations par lots

Pour les applications à haut débit, Rememberizer prend en charge des opérations par lots efficaces sur les magasins de vecteurs. Ces méthodes optimisent les performances lors du traitement de plusieurs requêtes de recherche.

Mise en œuvre de la recherche par lots

Python

import requests
import time
import concurrent.futures

def batch_search_vector_store(vector_store_id, queries, num_results=5, batch_size=10):
    """
    Effectuer des recherches par lots contre un magasin de vecteurs
    
    Args:
        vector_store_id: ID du magasin de vecteurs à rechercher
        queries: Liste de chaînes de requêtes de recherche
        num_results: Nombre de résultats par requête
        batch_size: Nombre de requêtes parallèles
        
    Returns:
        Liste des résultats de recherche
    """
    headers = {
        "x-api-key": "YOUR_API_KEY"
    }
    
    results = []
    
    # Traiter par lots pour éviter de surcharger l'API
    for i in range(0, len(queries), batch_size):
        batch_queries = queries[i:i+batch_size]
        
        with concurrent.futures.ThreadPoolExecutor(max_workers=batch_size) as executor:
            futures = []
            
            for query in batch_queries:
                params = {
                    "q": query,
                    "n": num_results,
                    "prev_chunks": 1,
                    "next_chunks": 1
                }
                
                # Soumettre la requête au pool de threads
                future = executor.submit(
                    requests.get,
                    f"https://api.rememberizer.ai/api/v1/vector-stores/{vector_store_id}/documents/search",
                    headers=headers,
                    params=params
                )
                futures.append(future)
            
            # Collecter les résultats de tous les futurs
            for future in futures:
                response = future.result()
                if response.status_code == 200:
                    results.append(response.json())
                else:
                    results.append({"error": f"Échec avec le code d'état : {response.status_code}"})
        
        # Ajouter un délai entre les lots pour éviter la limitation de débit
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Exemple d'utilisation
queries = [
    "Intégration avec les API REST",
    "Protocoles d'authentification",
    "Comment déployer en production",
    "Techniques d'optimisation des performances",
    "Meilleures pratiques de gestion des erreurs"
]

search_results = batch_search_vector_store("vs_abc123", queries, num_results=3, batch_size=5)

JavaScript

/**
 * Effectuer des recherches par lots contre un magasin de vecteurs
 * 
 * @param {string} vectorStoreId - ID du magasin de vecteurs
 * @param {string[]} queries - Liste des requêtes de recherche
 * @param {Object} options - Options de configuration
 * @returns {Promise<Array>} - Liste des résultats de recherche
 */
async function batchSearchVectorStore(vectorStoreId, queries, options = {}) {
  const {
    numResults = 5,
    batchSize = 10,
    delayBetweenBatches = 1000,
    prevChunks = 1,
    nextChunks = 1,
    distanceThreshold = 0.7
  } = options;
  
  const results = [];
  const apiKey = 'YOUR_API_KEY';
  
  // Traiter par lots pour gérer la charge de l'API
  for (let i = 0; i < queries.length; i += batchSize) {
    const batchQueries = queries.slice(i, i + batchSize);
    
    // Créer un tableau de promesses pour des requêtes parallèles
    const batchPromises = batchQueries.map(query => {
      const url = new URL(`https://api.rememberizer.ai/api/v1/vector-stores/${vectorStoreId}/documents/search`);
      url.searchParams.append('q', query);
      url.searchParams.append('n', numResults);
      url.searchParams.append('prev_chunks', prevChunks);
      url.searchParams.append('next_chunks', nextChunks);
      url.searchParams.append('t', distanceThreshold);
      
      return fetch(url.toString(), {
        method: 'GET',
        headers: {
          'x-api-key': apiKey
        }
      })
      .then(response => {
        if (response.ok) {
          return response.json();
        } else {
          return { error: `Échec avec le statut : ${response.status}` };
        }
      })
      .catch(error => {
        return { error: error.message };
      });
    });
    
    // Attendre que toutes les requêtes du lot soient terminées
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Ajouter un délai entre les lots pour éviter la limitation de débit
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Exemple d'utilisation
const queries = [
  "Intégration avec les API REST",
  "Protocoles d'authentification",
  "Comment déployer en production",
  "Techniques d'optimisation des performances",
  "Meilleures pratiques de gestion des erreurs"
];

const options = {
  numResults: 3,
  batchSize: 5,
  delayBetweenBatches: 1000,
  prevChunks: 1,
  nextChunks: 1
};

batchSearchVectorStore("vs_abc123", queries, options)
  .then(results => console.log(results))
  .catch(error => console.error("La recherche par lots a échoué :", error));

Ruby

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

# Effectuer des recherches par lots contre un magasin de vecteurs
#
# @param vector_store_id [String] ID du magasin de vecteurs
# @param queries [Array<String>] Liste des requêtes de recherche
# @param num_results [Integer] Nombre de résultats par requête
# @param batch_size [Integer] Nombre de requêtes parallèles
# @param delay_between_batches [Float] Secondes à attendre entre les lots
# @return [Array] Résultats de recherche pour chaque requête
def batch_search_vector_store(vector_store_id, queries, num_results: 5, batch_size: 10, delay_between_batches: 1.0)
  results = []
  api_key = 'YOUR_API_KEY'
  
  # Traitement par lots
  queries.each_slice(batch_size).with_index do |batch_queries, batch_index|
    # Créer un pool de threads pour une exécution concurrente
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch_queries.each do |query|
      # Soumettre chaque requête au pool de threads
      futures << Concurrent::Future.execute(executor: pool) do
        uri = URI("https://api.rememberizer.ai/api/v1/vector-stores/#{vector_store_id}/documents/search")
        params = {
          q: query,
          n: num_results,
          prev_chunks: 1,
          next_chunks: 1
        }
        
        uri.query = URI.encode_www_form(params)
        
        request = Net::HTTP::Get.new(uri)
        request['x-api-key'] = api_key
        
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true
        
        begin
          response = http.request(request)
          
          if response.code.to_i == 200
            JSON.parse(response.body)
          else
            { "error" => "Échec avec le code d'état : #{response.code}" }
          end
        rescue => e
          { "error" => e.message }
        end
      end
    end
    
    # Collecter les résultats de tous les futurs
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Ajouter un délai entre les lots
    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 = [
  "Intégration avec les API REST",
  "Protocoles d'authentification",
  "Comment déployer en production", 
  "Techniques d'optimisation des performances",
  "Meilleures pratiques de gestion des erreurs"
]

results = batch_search_vector_store(
  "vs_abc123", 
  queries, 
  num_results: 3, 
  batch_size: 5
)

puts results

Optimisation des Performances pour les Opérations par Lots

Lors de la mise en œuvre d'opérations par lots pour les recherches dans le magasin de vecteurs, considérez ces meilleures pratiques :

1. Taille de Lot Optimale : Pour la plupart des applications, traiter 5 à 10 requêtes en parallèle offre un bon équilibre entre le débit et l'utilisation des ressources.

2. Connaissance des Limites de Taux : Incluez des mécanismes de délai entre les lots (généralement 1 à 2 secondes) pour éviter de dépasser les limites de taux de l'API.

3. Gestion des Erreurs : Mettez en œuvre une gestion robuste des erreurs pour les requêtes individuelles qui peuvent échouer dans un lot.

4. Gestion des Connexions : Pour les applications à fort volume, mettez en œuvre un pool de connexions pour réduire les frais généraux.

5. Configuration des Délais d'Attente : Définissez des délais d'attente appropriés pour chaque requête afin d'éviter que des requêtes longues ne bloquent l'ensemble du lot.

6. Traitement des Résultats : Envisagez de traiter les résultats de manière asynchrone au fur et à mesure qu'ils deviennent disponibles plutôt que d'attendre tous les résultats.

7. Surveillance : Suivez des indicateurs de performance tels que le temps de réponse moyen et les taux de réussite pour identifier les opportunités d'optimisation.

Pour les applications de production avec des volumes de requêtes très élevés, envisagez de mettre en œuvre un système de file d'attente avec des processus de travail pour gérer efficacement de grands lots.

Ce point de terminaison vous permet de rechercher dans votre magasin de vecteurs en utilisant la similarité sémantique. Il renvoie des documents qui sont conceptuellement liés à votre requête, même s'ils ne contiennent pas les mots-clés exacts. Cela le rend particulièrement puissant pour les requêtes en langage naturel et les réponses aux questions.