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
Initiate a search operation with a query text and receive most semantically similar responses from the vector store.
The ID of the vector store.
The search query text.
Number of chunks to return.
Matching threshold.
Number of chunks before the matched chunk to include.
Number of chunks after the matched chunk to include.
The API key for authentication.
GET /api/v1/vector-stores/{vector-store-id}/documents/search HTTP/1.1
Host: api.rememberizer.ai
x-api-key: text
Accept: */*
Search results retrieved successfully.
{
"vector_store": {
"id": "text",
"name": "text"
},
"matched_chunks": [
{
"document": {
"id": 1,
"name": "text",
"type": "text",
"size": 1,
"indexed_on": "2025-07-01T03:17:49.294Z",
"vector_store": "text",
"created": "2025-07-01T03:17:49.294Z",
"modified": "2025-07-01T03:17:49.294Z"
},
"matched_content": "text",
"distance": 1
}
]
}
Exemples de Requêtes
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"
Paramètres de chemin
vector-store-id
string
Requis. L'ID du magasin de vecteurs dans lequel rechercher.
Paramètres de requête
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
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
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)
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 :
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.
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.
Gestion des Erreurs : Mettez en œuvre une gestion robuste des erreurs pour les requêtes individuelles qui peuvent échouer dans un lot.
Gestion des Connexions : Pour les applications à fort volume, mettez en œuvre un pool de connexions pour réduire les frais généraux.
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.
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.
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.
Last updated