Télécharger des fichiers dans un magasin de vecteurs

Télécharger le contenu des fichiers vers le Vector Store avec des opérations par lots

post

Upload files to a vector store.

Path parameters

vector-store-idstringRequired

The ID of the vector store.

Header parameters

x-api-keystringRequired

The API key for authentication.

Body

filesstring · binary[]Optional

The files to upload.

Responses

201

Files uploaded successfully.

application/json

207

Some files failed to upload.

post

/vector-stores/{vector-store-id}/documents/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"
    }
  ]
}

Exemples de requêtes

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

Méthode d'aide pour déterminer le type de contenu

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

Exemple d'utilisation

result = upload_files('vs_abc123', ['/path/to/document1.pdf', '/path/to/document2.docx']) puts result


{% hint 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.
{% endhint %}
{% endtab %}
{% endtabs %}

## 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"
    }
  ]
}

Authentification

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

Formats de fichier pris en charge

PDF (.pdf)
Microsoft Word (.doc, .docx)
Microsoft Excel (.xls, .xlsx)
Microsoft PowerPoint (.ppt, .pptx)
Fichiers texte (.txt)
Markdown (.md)
JSON (.json)
HTML (.html, .htm)

Limites de Taille de Fichier

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

Réponses d'erreur

Code d'état

Description

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é

État du traitement

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 Get a List of Documents in a Vector Store. L'état final sera l'un des suivants :

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.

Opérations par lots

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.

Mise en œuvre du téléchargement par lots

{% tabs %} {% tab title="Python" %}

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']
)

{% endtab %}

{% tab title="JavaScript" %}

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

{% endtab %}

{% tab title="Ruby" %}

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
)

Meilleures Pratiques pour le Téléchargement par Lots

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.

PreviousMettre à jour le contenu d'un fichier dans un magasin de vecteurs NextAvis

Last updated 21 days ago