LlamaIndex

Construire des pipelines LlamaIndex data-to-LLM et des applications RAG sur les GPU 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 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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

---

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)

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.

---

Déploiement rapide sur CLORE.AI

1. Trouvez un serveur adapté

Aller à 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 :

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

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

Étape 2 : installez Ollama

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

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

# 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

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

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

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

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

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

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

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)

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

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 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é

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

# 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

# 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

# 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

# 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

# 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

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