LlamaIndex

Construye pipelines de datos a LLM y aplicaciones RAG con LlamaIndex en GPUs de Clore.ai

LlamaIndex (anteriormente GPT Index) es un marco de datos para aplicaciones con LLM con más de 37.000 estrellas en GitHub. Mientras que LangChain se centra en encadenar llamadas a LLM, LlamaIndex sobresale en ingestión de datos, indexación y consultas estructuradas — lo que lo convierte en la opción ideal cuando tu aplicación necesita razonar sobre colecciones de documentos grandes y heterogéneas.

LlamaIndex ofrece soporte de primera clase para estructuras de datos complejas (bases de datos, APIs, PDFs, páginas de Notion, repositorios de GitHub) y estrategias sofisticadas de recuperación. Ejecutarlo en servidores GPU de Clore.ai con LLMs locales elimina costos de API y mantiene tus datos privados.

Fortalezas clave:

• 📊 Conectores de datos — más de 160 integraciones (PDF, SQL, Notion, Slack, GitHub, etc.)

• 🗂️ Múltiples tipos de índice — vectorial, árbol, lista, palabras clave, grafo de conocimiento

• 🔍 Recuperación avanzada — descomposición en subpreguntas, recuperación recursiva, búsqueda híbrida

• 🤖 Motores de consulta — SQL, estructurado y lenguaje natural sobre cualquier fuente de datos

• 🧩 Multimodal — imágenes, audio y video junto con texto

• 💾 Persistencia — soporte integrado para ChromaDB, Pinecone, Weaviate, etc.

• ⚡ Primero asincrónico — diseñado para rendimiento en producción

• 🔗 Compatible con LangChain — usa ambos marcos juntos

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

---

Requisitos del servidor

Parámetro	Mínimo	Recomendado
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 GB (modelo 7B)	24 GB (modelos 13B–34B)
RAM	16 GB	32–64 GB
CPU	4 núcleos	16 núcleos
Disco	30 GB	Más de 100 GB (modelos locales + datos)
SO	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.8+	12.1+
Python	3.9+	3.11
Puertos	22, 8000	22, 8000, 11434 (Ollama)

LlamaIndex es una biblioteca de Python — los recursos GPU son consumidos por el LLM subyacente y el modelo de embeddings. Para despliegues en producción, combina LlamaIndex con Ollama (para inferencia local) y ChromaDB (para almacenamiento vectorial), ambos ejecutándose en tu servidor GPU de Clore.ai.

---

Despliegue rápido en CLORE.AI

1. Encuentra un servidor adecuado

Ve a CLORE.AI Marketplace y elige en función del tamaño de tu LLM:

Caso de uso	GPU	Notas
Desarrollo / Pruebas	RTX 3080 (10 GB)	Modelos 7B, conjuntos pequeños de documentos
Producción (pequeña)	RTX 4090 (24 GB)	Modelos 13B, conjuntos de datos medianos
Producción (grande)	A100 40G / 80G	Modelos 34B–70B, conjuntos de datos grandes
Empresa	H100 (80 GB)	Máximo rendimiento

2. Configura tu despliegue

Imagen Docker (base):

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

Mapeos de puertos:

22    → acceso SSH
8000  → API de LlamaIndex / UI de Gradio
11434 → motor de inferencia Ollama

Script de inicio:

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

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

python /workspace/app.py

3. Accede a la API

http://<tu-ip-servidor-clore>:8000

---

Configuración paso a paso

Paso 1: Conéctate por SSH a tu servidor

ssh root@<tu-ip-servidor-clore> -p <puerto-ssh>

Paso 2: Instala Ollama

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

# Descargar modelos
ollama pull llama3:8b              # LLM para generación
ollama pull nomic-embed-text       # Modelo de embeddings

# Verificar
ollama list

Paso 3: Configura el entorno Python

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

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

Paso 4: Instala los paquetes de LlamaIndex

# Núcleo de LlamaIndex
pip install llama-index

# Integraciones de LLM
pip install llama-index-llms-ollama
pip install llama-index-llms-openai     # Opcional: OpenAI

# Integraciones de embeddings
pip install llama-index-embeddings-ollama
pip install llama-index-embeddings-huggingface

# Integraciones con almacenes vectoriales
pip install llama-index-vector-stores-chroma

# Cargadores de datos
pip install llama-index-readers-file
pip install llama-index-readers-web

# Opcional: lectores adicionales
pip install pypdf docx2txt

Paso 5: Configura ajustes globales

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

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

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

# Configurar ajustes de fragmentación
Settings.chunk_size = 1024
Settings.chunk_overlap = 200

Paso 6: Construye tu primer índice

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Cargar documentos desde un directorio
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()
print(f"Loaded {len(documents)} documents")

# Construir índice vectorial (autogenera embeddings y almacena)
index = VectorStoreIndex.from_documents(documents)

# Guardar índice en disco
index.storage_context.persist("/workspace/index_storage")
print("Index built and saved!")

Paso 7: Consulta el índice

from llama_index.core import load_index_from_storage, StorageContext

# Cargar índice existente
storage_context = StorageContext.from_defaults(persist_dir="/workspace/index_storage")
index = load_index_from_storage(storage_context)

# Crear motor de consultas
query_engine = index.as_query_engine(similarity_top_k=5)

# Hacer preguntas
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")

---

Ejemplos de uso

Ejemplo 1: Preguntas y respuestas básicas sobre documentos

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

# Configurar LLamaIndex con modelos locales de Ollama
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"
)

# Crear directorio de documentos de ejemplo
data_dir = Path("/workspace/data")
data_dir.mkdir(exist_ok=True)

# Crear un documento de ejemplo
(data_dir / "clore_faq.txt").write_text("""
Preguntas frecuentes de Clore.ai

P: ¿Qué es Clore.ai?
R: Clore.ai es un mercado descentralizado de nubes GPU que conecta propietarios de GPU con investigadores y desarrolladores de IA que necesitan potencia de cómputo.

P: ¿Qué GPUs están disponibles?
R: Clore.ai ofrece GPUs que van desde la NVIDIA GTX 1080 hasta la más reciente H100 80GB. Las opciones populares incluyen RTX 4090, A100 40G/80G y RTX 3090.

P: ¿Cómo funciona la tarificación?
R: Los precios los establecen los proveedores de GPU y varían según el modelo de GPU, la VRAM y la disponibilidad. Generalmente son un 30-70% más baratos que AWS/GCP.

P: ¿Qué software puedo ejecutar?
R: Cualquier contenedor Docker. Hay imágenes preconfiguradas para PyTorch, TensorFlow, ComfyUI, Stable Diffusion y más.
""")

# Construir índice
documents = SimpleDirectoryReader(str(data_dir)).load_data()
index = VectorStoreIndex.from_documents(documents, show_progress=True)

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

questions = [
    "¿Qué GPUs ofrece Clore.ai?",
    "¿Cómo se compara la tarificación de Clore.ai con AWS?",
    "¿Puedo ejecutar contenedores Docker personalizados?",
]

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

---

Ejemplo 2: RAG de múltiples documentos con 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

# Configurar LLM y 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"
)

# Conectar a ChromaDB (ejecutándose en el mismo servidor de Clore.ai)
chroma_client = chromadb.HttpClient(host="localhost", port=8001)
chroma_collection = chroma_client.get_or_create_collection("llamaindex_docs")

# Crear almacén vectorial ChromaDB para LlamaIndex
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Cargar documentos desde múltiples fuentes
docs_dir = "/workspace/data/docs"
documents = SimpleDirectoryReader(
    docs_dir,
    recursive=True,              # Incluir subdirectorios
    required_exts=[".pdf", ".txt", ".md"],  # Solo estos formatos
    filename_as_id=True          # Usar el nombre de archivo como ID del doc
).load_data()

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

# Construir índice (almacena en ChromaDB)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("Index built and persisted in ChromaDB!")

# Cargar índice existente (sesiones futuras)
# index = VectorStoreIndex.from_vector_store(vector_store)

# Motor de consulta avanzado con filtrado por metadatos
from llama_index.core.vector_stores import MetadataFilter, MetadataFilters

# Consulta con filtro de metadatos
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}")

---

Ejemplo 3: Descomposición en subpreguntas

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

# Crear índices separados para diferentes dominios de conocimiento
def build_index(docs_path, index_name):
    docs = SimpleDirectoryReader(docs_path).load_data()
    index = VectorStoreIndex.from_documents(docs)
    return index

# Bases de conocimiento separadas
pricing_index = build_index("/workspace/data/pricing", "pricing")
technical_index = build_index("/workspace/data/technical", "technical")
faq_index = build_index("/workspace/data/faq", "faq")

# Envolver como herramientas
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="Contiene información de precios, comparaciones de costos y detalles de facturación para Clore.ai."
        )
    ),
    QueryEngineTool(
        query_engine=technical_index.as_query_engine(),
        metadata=ToolMetadata(
            name="technical_docs",
            description="Contiene documentación técnica sobre especificaciones de GPU, despliegue con Docker y APIs."
        )
    ),
    QueryEngineTool(
        query_engine=faq_index.as_query_engine(),
        metadata=ToolMetadata(
            name="faq_docs",
            description="Contiene preguntas frecuentes y sus respuestas."
        )
    ),
]

# El motor de subpreguntas descompone consultas complejas
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=tools,
    verbose=True
)

# Pregunta compleja de varias partes
complex_question = """
Compara el costo de ejecutar un LLM de 7B parámetros en Clore.ai frente a AWS durante 100 horas,
y explica la configuración técnica necesaria para cada opción.
"""

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

---

Ejemplo 4: Índice de grafo de conocimiento

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")  # Modelo más grande para mejor extracción
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Cargar documentos
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()

# Construir Grafo de Conocimiento (extrae entidades y relaciones)
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=10,   # Extraer hasta 10 tripletas por fragmento
    include_embeddings=True,
    show_progress=True
)

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

# Consultar el grafo de conocimiento
kg_query_engine = kg_index.as_query_engine(
    include_text=True,            # Incluir texto fuente
    retriever_mode="keyword",     # Usar recuperación basada en palabras clave
    response_mode="tree_summarize"
)

questions = [
    "¿Cuáles son las relaciones entre modelos de GPU y casos de uso?",
    "¿Cómo se relacionan la tarificación y las especificaciones de las GPU?",
    "¿Qué métodos de despliegue se conectan a qué servicios?",
]

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

---

Ejemplo 5: Motor de consulta SQL sobre base de datos

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

# Crear base de datos de ejemplo con datos del mercado de GPUs
engine = create_engine("sqlite:////workspace/clore_data.db")

# Crear y poblar tablas
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()

# Crear wrapper de base de datos SQL de LlamaIndex
sql_database = SQLDatabase(engine, include_tables=["gpu_servers"])

# Motor de consulta de lenguaje natural a SQL
query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    tables=["gpu_servers"],
)

# Consultar la base de datos en lenguaje natural
nl_queries = [
    "¿Cuál es el servidor GPU más barato disponible?",
    "Muéstrame todos los servidores GPU con más de 40GB de VRAM",
    "¿Cuál es el precio promedio por hora para servidores RTX 4090?",
    "¿Qué ubicaciones tienen servidores GPU disponibles?",
    "Lista todos los servidores A100 disponibles ordenados por precio",
]

for query in nl_queries:
    print(f"\n💬 Lenguaje natural: {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']}")

---

Configuración

Docker Compose (Stack completo de 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 clave de configuración

Ajuste	Por defecto	Descripción
Settings.llm	OpenAI GPT-3.5	LLM para generación
Settings.embed_model	OpenAI Ada	Modelo de embeddings
Settings.chunk_size	1024	Tamaño del fragmento de texto en tokens
Settings.chunk_overlap	200	Superposición entre fragmentos
Settings.num_output	256	Máx. tokens en la respuesta del LLM
Settings.context_window	4096	Tamaño de la ventana de contexto del LLM

---

Consejos de rendimiento

1. Consultas asíncronas para rendimiento

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. Búsqueda híbrida (palabra clave + semántica)

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

# Combinar recuperación vectorial y por palabras clave
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # Recuperación vectorial
        index.as_retriever(retriever_mode="keyword"),  # Recuperación por palabras clave
    ],
    similarity_top_k=5,
    num_queries=3,  # Generar múltiples variaciones de consulta
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)

3. Reordenamiento para calidad

from llama_index.core.postprocessor import SentenceTransformerRerank

# Añadir paso de reordenamiento después de la recuperación
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=3
)

query_engine = index.as_query_engine(
    similarity_top_k=10,  # Recuperar más candidatos
    node_postprocessors=[reranker]  # Reordenar a los 3 mejores
)

4. Streaming para UIs responsivas

# Transmitir tokens a medida que se generan
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)

---

Solución de problemas

Problema: el modelo de embeddings no se conecta a Ollama

# Probar embeddings de Ollama directamente
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "test text"
}'

Problema: la construcción del índice es lenta

# Supervisar el uso de GPU durante la generación de embeddings
watch -n1 nvidia-smi

# Usa tamaños de lote más pequeños
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
    docs,
    show_progress=True,
    # Inserta en lotes más pequeños
)

Problema: ModuleNotFoundError para integraciones

# LlamaIndex utiliza arquitectura de plugins en v0.10+
pip install llama-index-llms-ollama
pip install llama-index-embeddings-ollama
pip install llama-index-vector-stores-chroma

# Comprueba los paquetes instalados
pip list | grep llama

Problema: Ventana de contexto excedida

# Reduce el tamaño de los fragmentos
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# O usa un modelo con contexto más amplio
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # Extender la ventana de contexto
)

Problema: Las consultas devuelven resultados irrelevantes

# Aumenta similarity top-k
query_engine = index.as_query_engine(similarity_top_k=10)

# O usa un mejor modelo de embeddings
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-large-en-v1.5"
)

---

Enlaces

• GitHub: https://github.com/run-llama/llama_index

• Documentación oficial: https://docs.llamaindex.ai

• PyPI: https://pypi.org/project/llama-index

• Integraciones: https://llamahub.ai

• Discord: https://discord.gg/dGcwcsnxhU

• Blog: https://www.llamaindex.ai/blog

• CLORE.AI Marketplace: https://clore.ai/marketplace

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
RAG en producción	RTX 3090 (24GB)	~$0.12/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.