Télécharger des fichiers dans un stockage vectoriel
Télécharger le contenu des fichiers vers le Vector Store avec des opérations par lots
Last updated
Télécharger le contenu des fichiers vers le Vector Store avec des opérations par lots
Last updated
curl -X POST \
https://api.rememberizer.ai/api/v1/vector-stores/vs_abc123/documents/upload \
-H "x-api-key: VOTRE_CLE_API" \
-F "files=@/chemin/vers/document1.pdf" \
-F "files=@/chemin/vers/document2.docx"
Remplacez VOTRE_CLE_API
par votre véritable clé API de Vector Store, vs_abc123
par votre ID de Vector Store, et fournissez les chemins vers vos fichiers locaux.
const uploadFiles = async (vectorStoreId, files) => {
const formData = new FormData();
// Ajouter plusieurs fichiers aux données du formulaire
for (const file of files) {
formData.append('files', file);
}
const response = await fetch(`https://api.rememberizer.ai/api/v1/vector-stores/${vectorStoreId}/documents/upload`, {
method: 'POST',
headers: {
'x-api-key': 'VOTRE_CLE_API'
// Remarque : Ne pas définir l'en-tête Content-Type, il sera défini automatiquement avec la bonne frontière
},
body: formData
});
const data = await response.json();
console.log(data);
};
// Exemple d'utilisation avec un élément d'entrée de fichier
const fileInput = document.getElementById('fileInput');
uploadFiles('vs_abc123', fileInput.files);
Remplacez VOTRE_CLE_API
par votre véritable clé API de Vector Store et vs_abc123
par votre ID de Vector Store.
import requests
def upload_files(vector_store_id, file_paths):
headers = {
"x-api-key": "VOTRE_CLE_API"
}
files = [('files', (file_path.split('/')[-1], open(file_path, 'rb'))) for file_path in file_paths]
response = requests.post(
f"https://api.rememberizer.ai/api/v1/vector-stores/{vector_store_id}/documents/upload",
headers=headers,
files=files
)
data = response.json()
print(data)
upload_files('vs_abc123', ['/chemin/vers/document1.pdf', '/chemin/vers/document2.docx'])
Remplacez VOTRE_CLE_API
par votre véritable clé API de Vector Store, vs_abc123
par votre ID de Vector Store, et fournissez les chemins vers vos fichiers locaux.
require 'net/http'
require 'uri'
require 'json'
def upload_files(vector_store_id, file_paths)
uri = URI("https://api.rememberizer.ai/api/v1/vector-stores/#{vector_store_id}/documents/upload")
# Créer un nouvel objet HTTP
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
# Créer une requête multipart-form
request = Net::HTTP::Post.new(uri)
request['x-api-key'] = 'VOTRE_CLE_API'
# Créer une frontière multipart
boundary = "RubyFormBoundary#{rand(1000000)}"
request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
# Construire le corps de la requête
body = []
file_paths.each do |file_path|
file_name = File.basename(file_path)
file_content = File.read(file_path, mode: 'rb')
body << "--#{boundary}\r\n"
body << "Content-Disposition: form-data; name=\"files\"; filename=\"#{file_name}\"\r\n"
body << "Content-Type: #{get_content_type(file_name)}\r\n\r\n"
body << file_content
body << "\r\n"
end
body << "--#{boundary}--\r\n"
request.body = body.join
# Envoyer la requête
response = http.request(request)
# Analyser et retourner la réponse
JSON.parse(response.body)
end
def get_content_type(filename) ext = File.extname(filename).downcase case ext when '.pdf' then 'application/pdf' when '.doc' then 'application/msword' when '.docx' then 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' when '.txt' then 'text/plain' when '.md' then 'text/markdown' when '.json' then 'application/json' else 'application/octet-stream' end end
result = upload_files('vs_abc123', ['/path/to/document1.pdf', '/path/to/document2.docx']) puts result
<div data-gb-custom-block data-tag="hint" data-style='info'>
Remplacez `YOUR_API_KEY` par votre véritable clé API de Vector Store, `vs_abc123` par votre ID de Vector Store, et fournissez les chemins vers vos fichiers locaux.
</div>
</div>
</div>
## Paramètres de chemin
| Paramètre | Type | Description |
|--------------------|--------|--------------------------------------------------------------------|
| vector-store-id | string | **Requis.** L'ID du magasin de vecteurs pour télécharger des fichiers. |
## Corps de la demande
Ce point de terminaison accepte une requête `multipart/form-data` avec un ou plusieurs fichiers dans le champ `files`.
## Format de Réponse
```json
{
"documents": [
{
"id": 1234,
"name": "document1.pdf",
"type": "application/pdf",
"size": 250000,
"status": "processing",
"created": "2023-06-15T10:15:00Z",
"vector_store": "vs_abc123"
},
{
"id": 1235,
"name": "document2.docx",
"type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"size": 180000,
"status": "processing",
"created": "2023-06-15T10:15:00Z",
"vector_store": "vs_abc123"
}
],
"errors": []
}
Si certains fichiers échouent à être téléchargés, ils seront listés dans le tableau errors
:
{
"documents": [
{
"id": 1234,
"name": "document1.pdf",
"type": "application/pdf",
"size": 250000,
"status": "processing",
"created": "2023-06-15T10:15:00Z",
"vector_store": "vs_abc123"
}
],
"errors": [
{
"file": "document2.docx",
"error": "Format de fichier non pris en charge"
}
]
}
Ce point de terminaison nécessite une authentification à l'aide d'une clé API dans l'en-tête x-api-key
.
PDF (.pdf
)
Microsoft Word (.doc
, .docx
)
Microsoft Excel (.xls
, .xlsx
)
Microsoft PowerPoint (.ppt
, .pptx
)
Fichiers texte (.txt
)
Markdown (.md
)
JSON (.json
)
HTML (.html
, .htm
)
Limite de taille de fichier individuelle : 50 Mo
Limite de taille totale de la requête : 100 Mo
Nombre maximum de fichiers par requête : 20
400
Mauvaise demande - Aucun fichier fourni ou format de demande invalide
401
Non autorisé - Clé API invalide ou manquante
404
Non trouvé - Magasin de vecteurs non trouvé
413
Charge utile trop grande - Les fichiers dépassent la limite de taille
415
Type de média non pris en charge - Format de fichier non pris en charge
500
Erreur interne du serveur
207
Multi-Statut - Certains fichiers ont été téléchargés avec succès, mais d'autres ont échoué
done
: Le document a été traité avec succès
error
: Une erreur s'est produite lors du traitement
processing
: Le document est encore en cours de traitement
Le temps de traitement dépend de la taille et de la complexité du fichier. Le temps de traitement typique est compris entre 30 secondes et 5 minutes par document.
Pour télécharger efficacement plusieurs fichiers vers votre Vector Store, Rememberizer prend en charge les opérations par lots. Cette approche aide à optimiser les performances lors du traitement d'un grand nombre de documents.
import os
import requests
import time
import concurrent.futures
from pathlib import Path
def batch_upload_to_vector_store(vector_store_id, folder_path, batch_size=5, file_types=None):
"""
Télécharger tous les fichiers d'un répertoire vers un Vector Store par lots
Args:
vector_store_id: ID du vector store
folder_path: Chemin vers le dossier contenant les fichiers à télécharger
batch_size: Nombre de fichiers à télécharger dans chaque lot
file_types: Liste optionnelle des extensions de fichiers à filtrer (par exemple, ['.pdf', '.docx'])
Returns:
Liste des résultats de téléchargement
"""
api_key = "YOUR_API_KEY"
headers = {"x-api-key": api_key}
# Obtenir la liste des fichiers dans le répertoire
files = []
for entry in os.scandir(folder_path):
if entry.is_file():
file_path = Path(entry.path)
# Filtrer par extension de fichier si spécifié
if file_types is None or file_path.suffix.lower() in file_types:
files.append(file_path)
print(f"Trouvé {len(files)} fichiers à télécharger")
results = []
# Traiter les fichiers par lots
for i in range(0, len(files), batch_size):
batch = files[i:i+batch_size]
print(f"Traitement du lot {i//batch_size + 1}/{(len(files) + batch_size - 1)//batch_size}: {len(batch)} fichiers")
# Télécharger le lot
upload_files = []
for file_path in batch:
upload_files.append(('files', (file_path.name, open(file_path, 'rb'))))
try:
response = requests.post(
f"https://api.rememberizer.ai/api/v1/vector-stores/{vector_store_id}/documents/upload",
headers=headers,
files=upload_files
)
# Fermer tous les descripteurs de fichiers
for _, (_, file_obj) in upload_files:
file_obj.close()
if response.status_code in (200, 201, 207):
batch_result = response.json()
results.append(batch_result)
print(f"Téléchargement réussi du lot - {len(batch_result.get('documents', []))} documents traités")
# Vérifier les erreurs
if batch_result.get('errors') and len(batch_result['errors']) > 0:
print(f"Erreurs rencontrées : {len(batch_result['errors'])}")
for error in batch_result['errors']:
print(f"- {error['file']}: {error['error']}")
else:
print(f"Échec du téléchargement du lot avec le code d'état {response.status_code}: {response.text}")
results.append({"error": f"Échec du lot : {response.text}"})
except Exception as e:
print(f"Exception lors du téléchargement par lots : {str(e)}")
results.append({"error": str(e)})
# Fermer tous les descripteurs de fichiers restants en cas d'exception
for _, (_, file_obj) in upload_files:
try:
file_obj.close()
except:
pass
# Limitation de débit - pause entre les lots
if i + batch_size < len(files):
print("Pause avant le prochain lot...")
time.sleep(2)
return results
# Exemple d'utilisation
results = batch_upload_to_vector_store(
'vs_abc123',
'/path/to/documents/folder',
batch_size=5,
file_types=['.pdf', '.docx', '.txt']
)
/**
* Télécharger des fichiers vers un Vector Store par lots
*
* @param {string} vectorStoreId - ID du Vector Store
* @param {FileList|File[]} files - Fichiers à télécharger
* @param {Object} options - Options de configuration
* @returns {Promise<Array>} - Liste des résultats de téléchargement
*/
async function batchUploadToVectorStore(vectorStoreId, files, options = {}) {
const {
batchSize = 5,
delayBetweenBatches = 2000,
onProgress = null
} = options;
const apiKey = 'YOUR_API_KEY';
const results = [];
const fileList = Array.from(files);
const totalBatches = Math.ceil(fileList.length / batchSize);
console.log(`Préparation pour télécharger ${fileList.length} fichiers en ${totalBatches} lots`);
// Traiter les fichiers par lots
for (let i = 0; i < fileList.length; i += batchSize) {
const batch = fileList.slice(i, i + batchSize);
const batchNumber = Math.floor(i / batchSize) + 1;
console.log(`Traitement du lot ${batchNumber}/${totalBatches}: ${batch.length} fichiers`);
if (onProgress) {
onProgress({
currentBatch: batchNumber,
totalBatches: totalBatches,
filesInBatch: batch.length,
totalFiles: fileList.length,
completedFiles: i
});
}
// Créer FormData pour ce lot
const formData = new FormData();
batch.forEach(file => {
formData.append('files', file);
});
try {
const response = await fetch(
`https://api.rememberizer.ai/api/v1/vector-stores/${vectorStoreId}/documents/upload`,
{
method: 'POST',
headers: {
'x-api-key': apiKey
},
body: formData
}
);
if (response.ok) {
const batchResult = await response.json();
results.push(batchResult);
console.log(`Téléchargement réussi du lot - ${batchResult.documents?.length || 0} documents traités`);
// Vérifier les erreurs
if (batchResult.errors && batchResult.errors.length > 0) {
console.warn(`Erreurs rencontrées : ${batchResult.errors.length}`);
batchResult.errors.forEach(error => {
console.warn(`- ${error.file}: ${error.error}`);
});
}
} else {
console.error(`Échec du téléchargement du lot avec le statut ${response.status}: ${await response.text()}`);
results.push({ error: `Échec du lot avec le statut : ${response.status}` });
}
} catch (error) {
console.error(`Exception lors du téléchargement du lot : ${error.message}`);
results.push({ error: error.message });
}
// Ajouter un délai entre les lots pour éviter la limitation de débit
if (i + batchSize < fileList.length) {
console.log(`Pause de ${delayBetweenBatches}ms avant le prochain lot...`);
await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
}
}
console.log(`Téléchargement terminé. ${fileList.length} fichiers traités.`);
return results;
}
// Exemple d'utilisation avec un élément d'entrée de fichier
document.getElementById('upload-button').addEventListener('click', async () => {
const fileInput = document.getElementById('file-input');
const vectorStoreId = 'vs_abc123';
const progressBar = document.getElementById('progress-bar');
try {
const results = await batchUploadToVectorStore(vectorStoreId, fileInput.files, {
batchSize: 5,
onProgress: (progress) => {
// Mettre à jour l'interface utilisateur de progression
const percentage = Math.round((progress.completedFiles / progress.totalFiles) * 100);
progressBar.style.width = `${percentage}%`;
progressBar.textContent = `${percentage}% (Lot ${progress.currentBatch}/${progress.totalBatches})`;
}
});
console.log('Résultats de téléchargement complets :', results);
} catch (error) {
console.error('Échec du téléchargement :', error);
}
});
require 'net/http'
require 'uri'
require 'json'
require 'mime/types'
# Télécharger des fichiers vers un magasin de vecteurs par lots
#
# @param vector_store_id [String] ID du Vector Store
# @param folder_path [String] Chemin vers le dossier contenant les fichiers à télécharger
# @param batch_size [Integer] Nombre de fichiers à télécharger dans chaque lot
# @param file_types [Array<String>] Tableau optionnel d'extensions de fichiers à filtrer
# @param delay_between_batches [Float] Secondes à attendre entre les lots
# @return [Array] Liste des résultats de téléchargement
def batch_upload_to_vector_store(vector_store_id, folder_path, batch_size: 5, file_types: nil, delay_between_batches: 2.0)
api_key = 'YOUR_API_KEY'
results = []
# Obtenir la liste des fichiers dans le répertoire
files = Dir.entries(folder_path)
.select { |f| File.file?(File.join(folder_path, f)) }
.select { |f| file_types.nil? || file_types.include?(File.extname(f).downcase) }
.map { |f| File.join(folder_path, f) }
puts "Trouvé #{files.count} fichiers à télécharger"
total_batches = (files.count.to_f / batch_size).ceil
# Traiter les fichiers par lots
files.each_slice(batch_size).with_index do |batch, batch_index|
puts "Traitement du lot #{batch_index + 1}/#{total_batches}: #{batch.count} fichiers"
# Préparer la requête HTTP
uri = URI("https://api.rememberizer.ai/api/v1/vector-stores/#{vector_store_id}/documents/upload")
request = Net::HTTP::Post.new(uri)
request['x-api-key'] = api_key
# Créer une frontière de formulaire multipart
boundary = "RubyBoundary#{rand(1000000)}"
request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
# Construire le corps de la requête
body = []
batch.each do |file_path|
file_name = File.basename(file_path)
mime_type = MIME::Types.type_for(file_path).first&.content_type || 'application/octet-stream'
begin
file_content = File.binread(file_path)
body << "--#{boundary}\r\n"
body << "Content-Disposition: form-data; name=\"files\"; filename=\"#{file_name}\"\r\n"
body << "Content-Type: #{mime_type}\r\n\r\n"
body << file_content
body << "\r\n"
rescue => e
puts "Erreur lors de la lecture du fichier #{file_path}: #{e.message}"
end
end
body << "--#{boundary}--\r\n"
request.body = body.join
# Envoyer la requête
begin
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
response = http.request(request)
if response.code.to_i == 200 || response.code.to_i == 201 || response.code.to_i == 207
batch_result = JSON.parse(response.body)
results << batch_result
puts "Téléchargement réussi du lot - #{batch_result['documents']&.count || 0} documents traités"
# Vérifier les erreurs
if batch_result['errors'] && !batch_result['errors'].empty?
puts "Erreurs rencontrées: #{batch_result['errors'].count}"
batch_result['errors'].each do |error|
puts "- #{error['file']}: #{error['error']}"
end
end
else
puts "Échec du téléchargement du lot avec le code d'état #{response.code}: #{response.body}"
results << { "error" => "Échec du lot: #{response.body}" }
end
rescue => e
puts "Exception lors du téléchargement du lot: #{e.message}"
results << { "error" => e.message }
end
# Limitation de débit - pause entre les lots
if batch_index < total_batches - 1
puts "Pause de #{delay_between_batches} secondes avant le prochain lot..."
sleep(delay_between_batches)
end
end
puts "Téléchargement terminé. Traitement de #{files.count} fichiers."
results
end
# Exemple d'utilisation
results = batch_upload_to_vector_store(
'vs_abc123',
'/path/to/documents/folder',
batch_size: 5,
file_types: ['.pdf', '.docx', '.txt'],
delay_between_batches: 2.0
)
Pour optimiser les performances et la fiabilité lors du téléchargement de grands volumes de fichiers :
Gérer la Taille des Lots : Gardez les tailles de lots entre 5 et 10 fichiers pour des performances optimales. Trop de fichiers dans une seule requête augmente le risque de délais d'attente.
Mettre en Œuvre une Limitation de Taux : Ajoutez des délais entre les lots (2-3 secondes recommandées) pour éviter d'atteindre les limites de taux de l'API.
Ajouter une Logique de Réessai d'Erreur : Pour les systèmes de production, mettez en œuvre une logique de réessai pour les téléchargements échoués avec un retour exponentiel.
Valider les Types de Fichiers : Pré-filtrez les fichiers pour vous assurer qu'ils sont des types pris en charge avant d'essayer de les télécharger.
Surveiller le Progrès des Lots : Pour les applications destinées aux utilisateurs, fournissez un retour d'information sur l'avancement des opérations par lots.
Gérer le Succès Partiel : L'API peut renvoyer un code d'état 207 pour un succès partiel. Vérifiez toujours les statuts des documents individuels.
Nettoyer les Ressources : Assurez-vous que tous les handles de fichiers sont correctement fermés, surtout en cas d'erreurs.
Paralléliser Judicieusement : Pour des téléchargements très volumineux (des milliers de fichiers), envisagez plusieurs processus de lots concurrents ciblant différents magasins de vecteurs, puis combinez les résultats plus tard si nécessaire.
Mettre en Œuvre des Checksums : Pour les données critiques, vérifiez l'intégrité des fichiers avant et après le téléchargement avec des checksums.
Consigner des Résultats Complets : Maintenez des journaux détaillés de toutes les opérations de téléchargement pour le dépannage.
En suivant ces meilleures pratiques, vous pouvez gérer efficacement l'ingestion de documents à grande échelle dans vos magasins de vecteurs.
Les fichiers sont initialement acceptés avec un statut de processing
. Vous pouvez vérifier l'état de traitement des documents en utilisant le point de terminaison . L'état final sera l'un des suivants :
Upload files to a vector store.
The ID of the vector store.
The API key for authentication.
The files to upload.
POST /api/v1/vector-stores/{vector-store-id}/documents/upload HTTP/1.1
Host: api.rememberizer.ai
x-api-key: text
Content-Type: multipart/form-data
Accept: */*
Content-Length: 20
{
"files": [
"binary"
]
}
{
"documents": [
{
"id": 1,
"name": "text"
}
],
"errors": [
{
"file": "text",
"error": "text"
}
]
}