> For the complete documentation index, see [llms.txt](https://docs.rememberizer.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rememberizer.ai/fr/ressources-pour-les-developpeurs/api-docs/vector-store/upload-files-to-a-vector-store.md).

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

{% openapi src="/files/k0wV9YEEppPnffcGeVUk" path="/vector-stores/{vector-store-id}/documents/upload" method="post" %}
[rememberizer\_openapi.yml](https://3811618827-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FwduaTA5Sz3nf9aH5k1S6%2Fuploads%2Fgit-blob-77b6137eeb641262ec8e531c78123c02b825b865%2Frememberizer_openapi.yml?alt=media\&token=9d0098e1-f392-4761-be64-ff6f2caad99e)
{% endopenapi %}

## Exemples de requêtes

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

```bash
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"
```

{% hint style="info" %}
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.
{% endhint %}
{% endtab %}

{% tab title="JavaScript" %}

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

{% hint style="info" %}
Remplacez `VOTRE_CLE_API` par votre véritable clé API de Vector Store et `vs_abc123` par votre ID de Vector Store.
{% endhint %}
{% endtab %}

{% tab title="Python" %}

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

{% hint style="info" %}
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.
{% endhint %}
{% endtab %}

{% tab title="Ruby" %}

```ruby
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` :

```json
{
  "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](/fr/ressources-pour-les-developpeurs/api-docs/vector-store/get-a-list-of-documents-in-a-vector-store.md). 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" %}

```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" %}

```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" %}

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

{% endtab %}
{% endtabs %}

### 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 :

1. **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.
2. **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.
3. **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.
4. **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.
5. **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.
6. **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.
7. **Nettoyer les Ressources** : Assurez-vous que tous les handles de fichiers sont correctement fermés, surtout en cas d'erreurs.
8. **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.
9. **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.
10. **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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/fr/ressources-pour-les-developpeurs/api-docs/vector-store/upload-files-to-a-vector-store.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.