> 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

Créez des pipelines de données vers LLM et des applications RAG avec LlamaIndex sur les GPU de Clore.ai

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 l'interrogation structurée** — ce qui en fait le choix privilégié lorsque votre application doit raisonner sur de vastes collections de documents hétérogènes.

LlamaIndex offre une prise en charge de premier ordre des 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 les serveurs GPU de Clore.ai avec des LLM locaux élimine les coûts d'API et garde vos données privées.

Principaux atouts :

* 📊 **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
* 🔍 **Recherche avancée** — décomposition en sous-questions, recherche 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 de ChromaDB, Pinecone, Weaviate, etc.
* ⚡ **Priorité à l'asynchrone** — conçu pour un débit de production
* 🔗 **Compatible avec LangChain** — utilisez les deux frameworks ensemble

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

***

## Exigences du serveur

| Paramètre              | Minimum                 | Recommandé                         |
| ---------------------- | ----------------------- | ---------------------------------- |
| GPU                    | NVIDIA RTX 3080 (10 GB) | NVIDIA RTX 4090 (24 GB)            |
| VRAM                   | 8 GB (modèle 7B)        | 24 GB (modèles 13B–34B)            |
| RAM                    | 16 Go                   | 32–64 GB                           |
| CPU                    | 4 cœurs                 | 16 cœurs                           |
| Disque                 | 30 Go                   | 100+ GB (modèles locaux + données) |
| Système d'exploitation | 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'embedding. 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é

Accédez à [la place de marché CLORE.AI](https://clore.ai/marketplace) et choisissez en fonction de la taille de votre LLM :

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

### 2. Configurez votre déploiement

**Image Docker (de base) :**

```
nvidia/cuda:12.8.1-cudnn-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://<your-clore-server-ip>:8000
```

***

## Configuration étape par étape

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

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

### Étape 2 : installez Ollama

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

# Télécharger les modèles
ollama pull llama3:8b              # LLM pour la génération
ollama pull nomic-embed-text       # Modèle d'embedding

# 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 packages LlamaIndex

```bash
# LlamaIndex de base
pip install llama-index

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

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

# Intégrations de stockage vectoriel
pip install llama-index-vector-stores-chroma

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

# Facultatif : 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"{len(documents)} documents chargés")

# Construire l'index vectoriel (embeddings et stockage automatiques)
index = VectorStoreIndex.from_documents(documents)

# Enregistrer l'index sur le disque
index.storage_context.persist("/workspace/index_storage")
print("Index construit et enregistré !")
```

### Étape 7 : interrogez l'index

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

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

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

# Poser des questions
response = query_engine.query("Quels serveurs GPU sont disponibles sur Clore.ai ?")
print(f"Réponse : {response}")
print(f"\nSources : {len(response.source_nodes)} nœuds utilisés")
```

***

## Exemples d'utilisation

### Exemple 1 : questions-réponses de base sur un document

```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 de documents d'exemple
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 qui met 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 de la NVIDIA GTX 1080 au tout dernier H100 80GB. Parmi les options populaires : 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é. Généralement 30 à 70 % moins cher qu'AWS/GCP.

Q : Quels logiciels puis-je exécuter ?
R : N'importe quel conteneur Docker. Des images préconfigurées pour PyTorch, TensorFlow, ComfyUI, Stable Diffusion et bien plus sont disponibles.
""")

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

# Interroger
query_engine = index.as_query_engine(similarity_top_k=3)

questions = [
    "Quels GPU Clore.ai propose-t-il ?",
    "Comment les tarifs de Clore.ai se comparent-ils à ceux d'AWS ?",
    "Puis-je exécuter des conteneurs Docker personnalisés ?",
]

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

***

### Exemple 2 : RAG multi-document 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 stockage 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"],  # Uniquement ces formats
    filename_as_id=True          # Utiliser le nom de fichier comme ID du document
).load_data()

print(f"{len(documents)} documents chargés depuis {docs_dir}")

# Construire l'index (stocké dans ChromaDB)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("Index construit et enregistré dans ChromaDB !")

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

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

# Interroger avec un 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("Résumez les principaux concepts techniques dans les documents.")
print(f"\nRéponse filtrée : {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 index distincts pour différents domaines de connaissances
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 sous forme d'outils
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="Contient des informations sur les prix, des comparaisons de coûts et les 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 des 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
"""
Comparez le coût d'exécution d'un LLM de 7 milliards de paramètres sur Clore.ai par rapport à AWS pendant 100 heures,
et expliquez la configuration technique requise pour chaque option.
"""

print(f"Question : {complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\nRéponse complète :\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 meilleure extraction
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Charger les 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 fragment
    include_embeddings=True,
    show_progress=True
)

# Enregistrer le graphe
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"Graphe de connaissances construit !")
print(f"Nœuds : {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 une récupération par mots-clés
    response_mode="tree_summarize"
)

questions = [
    "Quelles sont les relations entre les modèles de GPU et les cas d'utilisation ?",
    "Comment les prix et les spécifications des GPU sont-ils liés ?",
    "Quelles méthodes de déploiement se connectent à quels 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 place de marché GPU
engine = create_engine("sqlite:////workspace/clore_data.db")

# Créer et peupler 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 l'enveloppe de base de données SQL de 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 = [
    "Quel est le serveur GPU le moins cher disponible ?",
    "Montrez-moi tous les serveurs GPU avec plus de 40 Go de VRAM",
    "Quel est le prix moyen par heure des serveurs RTX 4090 ?",
    "Quels emplacements disposent de serveurs GPU disponibles ?",
    "Listez tous les serveurs A100 disponibles, triés par prix",
]

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

***

## Configuration

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

```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'intégration                            |
| `Settings.chunk_size`     | 1024           | Taille des segments de texte en tokens          |
| `Settings.chunk_overlap`  | 200            | Chevauchement entre les segments                |
| `Settings.num_output`     | 256            | Nombre maximal 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 mots-clés
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # Récupération vectorielle
        index.as_retriever(retriever_mode="keyword"),  # Récupération par mots-clés
    ],
    similarity_top_k=5,
    num_queries=3,  # Générer plusieurs variantes de requête
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)
```

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

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

# Ajouter une étape de re-classement 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]  # Reclasser dans le top 3
)
```

### 4. Diffusion en continu pour des IU réactives

```python
# Diffuser les jetons au fur et à mesure de leur génération
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("Expliquez comment fonctionne Clore.ai")

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

***

## Dépannage

### Problème : le modèle d'intégration ne se connecte pas à Ollama

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

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

```bash
# Surveiller l'utilisation du GPU pendant l'intégration
watch -n1 nvidia-smi

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

### Problème : ModuleNotFoundError pour les intégrations

```bash
# LlamaIndex utilise une architecture de plugins dans la version 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 morceaux
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# Ou utiliser un modèle avec un contexte plus large
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 le top-k de similarité
query_engine = index.as_query_engine(similarity_top_k=10)

# Ou utiliser un meilleur modèle d'intégration
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>
* **la place de marché CLORE.AI**: <https://clore.ai/marketplace>

***

## Recommandations GPU Clore.ai

| Cas d’utilisation       | GPU recommandé   | Coût estimé sur Clore.ai |
| ----------------------- | ---------------- | ------------------------ |
| Développement/Test      | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h        |
| RAG de production       | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h        |
| Embeddings à haut débit | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h        |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/llamaindex.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.