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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

---

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)

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.

---

Déploiement rapide sur CLORE.AI

1. Trouvez un serveur adapté

Accédez à la place de marché CLORE.AI 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 :

#!/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

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

Étape 2 : installez Ollama

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

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

# 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

# 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

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

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

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

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

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

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

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)

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

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)

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é

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

# 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

# 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

# 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

# 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

# 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

# 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 des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.