> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/llamaindex.md).

# LlamaIndex

LlamaIndex (anciennement GPT Index) est un **cadre de données pour les applications LLM** avec plus de **37 000 étoiles GitHub**. Alors que LangChain se concentre sur l'enchaînement des appels LLM, LlamaIndex excelle dans **l'ingestion de données, l'indexation et les requêtes structurées** — faisant de lui le choix de référence lorsque votre application doit raisonner sur de grandes collections de documents hétérogènes.

LlamaIndex offre un support de premier ordre pour les structures de données complexes (bases de données, API, PDF, pages Notion, dépôts GitHub) et des stratégies de récupération sophistiquées. L'exécuter sur des serveurs GPU Clore.ai avec des LLM locaux élimine les coûts d'API et préserve la confidentialité de vos données.

Points forts :

* 📊 **Connecteurs de données** — plus de 160 intégrations (PDF, SQL, Notion, Slack, GitHub, etc.)
* 🗂️ **Plusieurs types d'index** — vecteur, arbre, liste, mot-clé, graphe de connaissances
* 🔍 **Récupération avancée** — décomposition en sous-questions, récupération récursive, recherche hybride
* 🤖 **Moteurs de requête** — SQL, structuré et langage naturel sur n'importe quelle source de données
* 🧩 **Multi-modal** — images, audio et vidéo en plus du texte
* 💾 **Persistance** — prise en charge intégrée pour ChromaDB, Pinecone, Weaviate, etc.
* ⚡ **Conçu pour l'asynchrone** — conçu pour le débit en production
* 🔗 **Compatible LangChain** — utilisez les deux cadres ensemble

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

***

## Exigences serveur

| Paramètre | Minimum                 | Recommandé                         |
| --------- | ----------------------- | ---------------------------------- |
| GPU       | NVIDIA RTX 3080 (10 Go) | NVIDIA RTX 4090 (24 Go)            |
| VRAM      | 8 Go (modèle 7B)        | 24 Go (modèles 13B–34B)            |
| RAM       | 16 Go                   | 32–64 Go                           |
| CPU       | 4 cœurs                 | 16 cœurs                           |
| Disque    | 30 Go                   | 100+ Go (modèles locaux + données) |
| OS        | Ubuntu 20.04+           | Ubuntu 22.04                       |
| CUDA      | 11.8+                   | 12.1+                              |
| Python    | 3.9+                    | 3.11                               |
| Ports     | 22, 8000                | 22, 8000, 11434 (Ollama)           |

{% hint style="info" %}
LlamaIndex est une bibliothèque Python — les ressources GPU sont consommées par le LLM sous-jacent et le modèle d'embeddings. Pour les déploiements en production, associez LlamaIndex à Ollama (pour l'inférence locale) et ChromaDB (pour le stockage vectoriel), tous deux exécutés sur votre serveur GPU Clore.ai.
{% endhint %}

***

## Déploiement rapide sur CLORE.AI

### 1. Trouvez un serveur adapté

Aller à [CLORE.AI Marketplace](https://clore.ai/marketplace) et choisissez en fonction de la taille de votre LLM :

| Cas d’utilisation     | GPU              | Remarques                                    |
| --------------------- | ---------------- | -------------------------------------------- |
| Développement / Tests | RTX 3080 (10 Go) | modèles 7B, petits ensembles de documents    |
| Production (petite)   | RTX 4090 (24 Go) | modèles 13B, ensembles de données moyens     |
| Production (grande)   | A100 40G / 80G   | modèles 34B–70B, grands ensembles de données |
| Entreprise            | H100 (80 Go)     | Débit maximal                                |

### 2. Configurez votre déploiement

**Image Docker (de base) :**

```
nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04
```

**Mappages de ports :**

```
22    → accès SSH
8000  → API LlamaIndex / interface Gradio
11434 → moteur d'inférence Ollama
```

**Script de démarrage :**

```bash
#!/bin/bash
# Installer Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5
ollama pull llama3:8b
ollama pull nomic-embed-text

# Installer LlamaIndex
pip install llama-index llama-index-llms-ollama llama-index-embeddings-ollama
pip install chromadb fastapi uvicorn

python /workspace/app.py
```

### 3. Accédez à l'API

```
http://<votre-ip-serveur-clore> :8000
```

***

## Configuration étape par étape

### Étape 1 : connectez-vous en SSH sur votre serveur

```bash
ssh root@<votre-ip-serveur-clore> -p <port-ssh>
```

### Étape 2 : installez Ollama

```bash
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5

# Récupérer les modèles
ollama pull llama3:8b              # LLM pour la génération
ollama pull nomic-embed-text       # Modèle d'embeddings

# Vérifier
ollama list
```

### Étape 3 : configurez l'environnement Python

```bash
mkdir -p /workspace/llamaindex-app
cd /workspace/llamaindex-app

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
```

### Étape 4 : installez les paquets LlamaIndex

```bash
# LlamaIndex cœur
pip install llama-index

# Intégrations LLM
pip install llama-index-llms-ollama
pip install llama-index-llms-openai     # Optionnel : OpenAI

# Intégrations d'embeddings
pip install llama-index-embeddings-ollama
pip install llama-index-embeddings-huggingface

# Intégrations de magasins vectoriels
pip install llama-index-vector-stores-chroma

# Chargeurs de données
pip install llama-index-readers-file
pip install llama-index-readers-web

# Optionnel : lecteurs supplémentaires
pip install pypdf docx2txt
```

### Étape 5 : configurez les paramètres globaux

```python
# settings.py
from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# Configurer le LLM
Settings.llm = Ollama(
    model="llama3:8b",
    base_url="http://localhost:11434",
    request_timeout=300.0,
    temperature=0.1,
)

# Configurer les embeddings
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434",
)

# Configurer les paramètres de découpage
Settings.chunk_size = 1024
Settings.chunk_overlap = 200
```

### Étape 6 : construisez votre premier index

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Charger des documents depuis un répertoire
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()
print(f"Loaded {len(documents)} documents")

# Construire l'index vectoriel (génère automatiquement les embeddings et stocke)
index = VectorStoreIndex.from_documents(documents)

# Enregistrer l'index sur le disque
index.storage_context.persist("/workspace/index_storage")
print("Index built and saved!")
```

### Étape 7 : interrogez l'index

```python
from llama_index.core import load_index_from_storage, StorageContext

# Charger un index existant
storage_context = StorageContext.from_defaults(persist_dir="/workspace/index_storage")
index = load_index_from_storage(storage_context)

# Créer un moteur de requête
query_engine = index.as_query_engine(similarity_top_k=5)

# Poser des questions
response = query_engine.query("What GPU servers are available on Clore.ai?")
print(f"Answer: {response}")
print(f"\nSources: {len(response.source_nodes)} nodes used")
```

***

## Exemples d’utilisation

### Exemple 1 : Q\&R basique sur documents

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from pathlib import Path

# Configurer LLamaIndex avec des modèles Ollama locaux
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# Créer un répertoire d'exemples de documents
data_dir = Path("/workspace/data")
data_dir.mkdir(exist_ok=True)

# Créer un document d'exemple
(data_dir / "clore_faq.txt").write_text("""
FAQ Clore.ai

Q : Qu'est-ce que Clore.ai ?
R : Clore.ai est une place de marché cloud GPU décentralisée mettant en relation les propriétaires de GPU avec des chercheurs et développeurs en IA qui ont besoin de puissance de calcul.

Q : Quels GPU sont disponibles ?
R : Clore.ai propose des GPU allant du NVIDIA GTX 1080 jusqu'au plus récent H100 80GB. Les options populaires incluent RTX 4090, A100 40G/80G et RTX 3090.

Q : Comment fonctionne la tarification ?
R : Les prix sont fixés par les fournisseurs de GPU et varient selon le modèle de GPU, la VRAM et la disponibilité. En général 30-70% moins cher qu'AWS/GCP.

Q : Quels logiciels puis-je exécuter ?
R : Tous les conteneurs Docker. Des images préconfigurées pour PyTorch, TensorFlow, ComfyUI, Stable Diffusion et plus sont disponibles.
""")

# Construire l'index
documents = SimpleDirectoryReader(str(data_dir)).load_data()
index = VectorStoreIndex.from_documents(documents, show_progress=True)

# Requête
query_engine = index.as_query_engine(similarity_top_k=3)

questions = [
    "What GPUs does Clore.ai offer?",
    "How does Clore.ai pricing compare to AWS?",
    "Can I run custom Docker containers?",
]

for q in questions:
    print(f"\n❓ {q}")
    response = query_engine.query(q)
    print(f"💬 {response}")
```

***

### Exemple 2 : RAG multi-documents avec ChromaDB

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext, Settings
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
import chromadb

# Configurer le LLM et les embeddings
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# Se connecter à ChromaDB (exécuté sur le même serveur Clore.ai)
chroma_client = chromadb.HttpClient(host="localhost", port=8001)
chroma_collection = chroma_client.get_or_create_collection("llamaindex_docs")

# Créer un magasin vectoriel ChromaDB pour LlamaIndex
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Charger des documents depuis plusieurs sources
docs_dir = "/workspace/data/docs"
documents = SimpleDirectoryReader(
    docs_dir,
    recursive=True,              # Inclure les sous-répertoires
    required_exts=[".pdf", ".txt", ".md"],  # Seulement ces formats
    filename_as_id=True          # Utiliser le nom de fichier comme ID de document
).load_data()

print(f"Loaded {len(documents)} documents from {docs_dir}")

# Construire l'index (stocke dans ChromaDB)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("Index built and persisted in ChromaDB!")

# Charger un index existant (sessions futures)
# index = VectorStoreIndex.from_vector_store(vector_store)

# Moteur de requête avancé avec filtrage par métadonnées
from llama_index.core.vector_stores import MetadataFilter, MetadataFilters

# Requête avec filtre de métadonnées
filtered_engine = index.as_query_engine(
    similarity_top_k=5,
    filters=MetadataFilters(
        filters=[
            MetadataFilter(key="file_type", value=".pdf"),
        ]
    )
)

response = filtered_engine.query("Summarize the key technical concepts in the documents.")
print(f"\nFiltered response: {response}")
```

***

### Exemple 3 : Décomposition en sous-questions

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Créer des indices séparés pour différents domaines de connaissance
def build_index(docs_path, index_name):
    docs = SimpleDirectoryReader(docs_path).load_data()
    index = VectorStoreIndex.from_documents(docs)
    return index

# Bases de connaissances séparées
pricing_index = build_index("/workspace/data/pricing", "pricing")
technical_index = build_index("/workspace/data/technical", "technical")
faq_index = build_index("/workspace/data/faq", "faq")

# Envelopper en outils
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="Contient des informations de tarification, des comparaisons de coûts et des détails de facturation pour Clore.ai."
        )
    ),
    QueryEngineTool(
        query_engine=technical_index.as_query_engine(),
        metadata=ToolMetadata(
            name="technical_docs",
            description="Contient la documentation technique sur les spécifications GPU, le déploiement Docker et les API."
        )
    ),
    QueryEngineTool(
        query_engine=faq_index.as_query_engine(),
        metadata=ToolMetadata(
            name="faq_docs",
            description="Contient les questions fréquemment posées et leurs réponses."
        )
    ),
]

# Le moteur de sous-questions décompose les requêtes complexes
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=tools,
    verbose=True
)

# Question complexe en plusieurs parties
complex_question = """
Compare the cost of running a 7B parameter LLM on Clore.ai vs AWS for 100 hours,
and explain the technical setup required for each option.
"""

print(f"Question: {complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\nComprehensive Answer:\n{response}")
```

***

### Exemple 4 : Index de graphe de connaissances

```python
from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:13b", base_url="http://localhost:11434")  # Modèle plus grand pour une extraction améliorée
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Charger des documents
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()

# Construire le graphe de connaissances (extrait les entités et les relations)
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=10,   # Extraire jusqu'à 10 triplets par chunk
    include_embeddings=True,
    show_progress=True
)

# Enregistrer le graphe
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"Knowledge graph built!")
print(f"Nodes: {len(kg_index.index_struct.table)}")

# Interroger le graphe de connaissances
kg_query_engine = kg_index.as_query_engine(
    include_text=True,            # Inclure le texte source
    retriever_mode="keyword",     # Utiliser la récupération par mot-clé
    response_mode="tree_summarize"
)

questions = [
    "What are the relationships between GPU models and use cases?",
    "How are pricing and GPU specifications related?",
    "What deployment methods connect to which services?",
]

for q in questions:
    print(f"\n🔍 {q}")
    response = kg_query_engine.query(q)
    print(f"📊 {response}")
```

***

### Exemple 5 : Moteur de requête SQL sur base de données

```python
from llama_index.core import SQLDatabase, Settings
from llama_index.core.query_engine import NLSQLTableQueryEngine
from llama_index.llms.ollama import Ollama
from sqlalchemy import create_engine, text
import pandas as pd

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")

# Créer une base de données d'exemple avec des données de marketplace GPU
engine = create_engine("sqlite:////workspace/clore_data.db")

# Créer et remplir les tables
with engine.connect() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS gpu_servers (
            id INTEGER PRIMARY KEY,
            gpu_model TEXT,
            vram_gb INTEGER,
            price_per_hour REAL,
            location TEXT,
            available INTEGER
        )
    """))

    conn.execute(text("""
        INSERT OR REPLACE INTO gpu_servers VALUES
        (1, 'RTX 4090', 24, 0.65, 'US-East', 1),
        (2, 'RTX 4090', 24, 0.70, 'EU-West', 1),
        (3, 'A100 80G', 80, 2.50, 'US-West', 1),
        (4, 'H100 80G', 80, 4.20, 'US-East', 0),
        (5, 'RTX 3090', 24, 0.35, 'Asia-Pacific', 1),
        (6, 'RTX 3080', 10, 0.20, 'EU-East', 1),
        (7, 'A100 40G', 40, 1.50, 'US-East', 1)
    """))
    conn.commit()

# Créer le wrapper de base de données SQL LlamaIndex
sql_database = SQLDatabase(engine, include_tables=["gpu_servers"])

# Moteur de requête de langage naturel vers SQL
query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    tables=["gpu_servers"],
)

# Interroger la base de données en langage naturel
nl_queries = [
    "What is the cheapest GPU server available?",
    "Show me all GPU servers with more than 40GB of VRAM",
    "What is the average price per hour for RTX 4090 servers?",
    "Which locations have GPU servers available?",
    "List all available A100 servers sorted by price",
]

for query in nl_queries:
    print(f"\n💬 Natural Language: {query}")
    response = query_engine.query(query)
    print(f"📊 Answer: {response}")
    if hasattr(response, 'metadata') and 'sql_query' in response.metadata:
        print(f"🔧 SQL: {response.metadata['sql_query']}")
```

***

## Configuration

### Docker Compose (Pile complète LlamaIndex)

```yaml
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    runtime: nvidia
    ports:
      - "11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    restart: unless-stopped

  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
    restart: unless-stopped

  llamaindex-api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: llamaindex-api
    ports:
      - "8000:8000"
    volumes:
      - ./data:/workspace/data
      - ./indices:/workspace/indices
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - CHROMA_HOST=chromadb
      - CHROMA_PORT=8000
      - LLM_MODEL=llama3:8b
      - EMBED_MODEL=nomic-embed-text
    depends_on:
      - ollama
      - chromadb
    restart: unless-stopped

volumes:
  ollama_models:
  chroma_data:
```

### Variables de configuration clés

| Paramètre                 | Par défaut     | Description                                 |
| ------------------------- | -------------- | ------------------------------------------- |
| `Settings.llm`            | OpenAI GPT-3.5 | LLM pour la génération                      |
| `Settings.embed_model`    | OpenAI Ada     | Modèle d'embeddings                         |
| `Settings.chunk_size`     | 1024           | Taille des chunks de texte en tokens        |
| `Settings.chunk_overlap`  | 200            | Chevauchement entre les chunks              |
| `Settings.num_output`     | 256            | Nombre max de tokens dans la réponse du LLM |
| `Settings.context_window` | 4096           | Taille de la fenêtre de contexte du LLM     |

***

## Conseils de performance

### 1. Requêtes asynchrones pour le débit

```python
import asyncio
from llama_index.core import VectorStoreIndex

query_engine = index.as_query_engine(use_async=True)

async def batch_query(questions):
    tasks = [query_engine.aquery(q) for q in questions]
    return await asyncio.gather(*tasks)

questions = ["Q1?", "Q2?", "Q3?", "Q4?", "Q5?"]
answers = asyncio.run(batch_query(questions))
```

### 2. Recherche hybride (mot-clé + sémantique)

```python
from llama_index.core import VectorStoreIndex
from llama_index.core.retrievers import VectorIndexRetriever, KeywordTableSimpleRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import QueryFusionRetriever

# Combiner la récupération vectorielle et par mot-clé
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # Récupération vectorielle
        index.as_retriever(retriever_mode="keyword"),  # Récupération par mot-clé
    ],
    similarity_top_k=5,
    num_queries=3,  # Générer plusieurs variations de requêtes
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)
```

### 3. Re-ranking pour la qualité

```python
from llama_index.core.postprocessor import SentenceTransformerRerank

# Ajouter une étape de re-ranking après la récupération
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=3
)

query_engine = index.as_query_engine(
    similarity_top_k=10,  # Récupérer plus de candidats
    node_postprocessors=[reranker]  # Re-classer pour ne garder que les 3 meilleurs
)
```

### 4. Streaming pour des UIs réactives

```python
# Diffuser les tokens au fur et à mesure de leur génération
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("Explain how Clore.ai works")

for token in response.response_gen:
    print(token, end="", flush=True)
```

***

## Dépannage

### Problème : le modèle d'embeddings ne se connecte pas à Ollama

```bash
# Tester les embeddings Ollama directement
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "test text"
}'
```

### Problème : la construction de l'index est lente

```bash
# Surveiller l'utilisation du GPU pendant l'embedding
watch -n1 nvidia-smi

# Utilisez des tailles de lot plus petites
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
    docs,
    show_progress=True,
    # Insérer en plus petits lots
)
```

### Problème : ModuleNotFoundError pour integrations

```bash
# LlamaIndex utilise une architecture de plugins en v0.10+
pip install llama-index-llms-ollama
pip install llama-index-embeddings-ollama
pip install llama-index-vector-stores-chroma

# Vérifier les paquets installés
pip list | grep llama
```

### Problème : Fenêtre de contexte dépassée

```python
# Réduire la taille des fragments
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# Ou utiliser un modèle avec un contexte plus grand
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # Étendre la fenêtre de contexte
)
```

### Problème : Les requêtes renvoient des résultats non pertinents

```python
# Augmenter similarity top-k
query_engine = index.as_query_engine(similarity_top_k=10)

# Ou utiliser un meilleur modèle d'embedding
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-large-en-v1.5"
)
```

***

## Liens

* **GitHub**: <https://github.com/run-llama/llama_index>
* **Documentation officielle**: <https://docs.llamaindex.ai>
* **PyPI**: <https://pypi.org/project/llama-index>
* **Intégrations**: <https://llamahub.ai>
* **Discord**: <https://discord.gg/dGcwcsnxhU>
* **Blog**: <https://www.llamaindex.ai/blog>
* **CLORE.AI Marketplace**: <https://clore.ai/marketplace>

***

## Recommandations GPU Clore.ai

| Cas d’utilisation       | GPU recommandé  | Coût estimé sur Clore.ai |
| ----------------------- | --------------- | ------------------------ |
| Développement/Test      | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| RAG en production       | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Embeddings à haut débit | RTX 4090 (24GB) | \~$0.70/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/llamaindex.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.