LlamaIndex

Crea canalizaciones de datos a LLM y aplicaciones RAG de LlamaIndex en las GPU de Clore.ai

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

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 de recuperación sofisticadas. Ejecutarlo en servidores GPU de Clore.ai con LLM locales elimina los 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, palabra clave, grafo de conocimiento

• 🔍 Recuperación avanzada — descomposición de 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.

• ⚡ Asincronía como prioridad — diseñado para rendimiento de producción

• 🔗 Compatible con LangChain — usa ambos marcos juntos

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

---

Requisitos del servidor

Parámetro	Mínimo	Recomendado
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 GB (modelo de 7B)	24 GB (modelos de 13B–34B)
RAM	16 GB	32–64 GB
CPU	4 núcleos	16 núcleos
Disco	30 GB	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 los consume 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 Marketplace de CLORE.AI y elige según el tamaño de tu LLM:

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

2. Configura tu despliegue

Imagen Docker (base):

nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04

Mapeos de puertos:

22    → acceso SSH
8000  → API de LlamaIndex / interfaz Gradio
11434 → motor de inferencia de 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

# Instala 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://<la-ip-de-tu-servidor-clore>:8000

---

Configuración paso a paso

Paso 1: conéctate por SSH a tu servidor

ssh root@<la-ip-de-tu-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

# LlamaIndex principal
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 de 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 los 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: crea tu primer índice

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

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

# Construir índice vectorial (se incrusta y almacena automáticamente)
index = VectorStoreIndex.from_documents(documents)

# Guardar el índice en disco
index.storage_context.persist("/workspace/index_storage")
print("¡Índice creado y guardado!")

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 consulta
query_engine = index.as_query_engine(similarity_top_k=5)

# Hacer preguntas
response = query_engine.query("¿Qué servidores GPU están disponibles en Clore.ai?")
print(f"Respuesta: {response}")
print(f"\nFuentes: se usaron {len(response.source_nodes)} nodos")

---

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 un 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 nube GPU que conecta a 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 fijan los proveedores de GPU y varían según el modelo de GPU, la VRAM y la disponibilidad. Por lo general, son entre un 30 % y un 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.
""")

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

# Consultar
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 multdocumento 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 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 de 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 del archivo como ID del documento
).load_data()

print(f"Se cargaron {len(documents)} documentos desde {docs_dir}")

# Crear índice (se almacena en ChromaDB)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("¡Índice creado y persistido en ChromaDB!")

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

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

# Consultar 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("Resume los conceptos técnicos clave de los documentos.")
print(f"\nRespuesta filtrada: {response}")

---

Ejemplo 3: descomposición de 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 distintos 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 de 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 requerida para cada opción.
"""

print(f"Pregunta: {complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\nRespuesta completa:\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 una 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 tripletes por fragmento
    include_embeddings=True,
    show_progress=True
)

# Guardar el grafo
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"¡Grafo de conocimiento creado!")
print(f"Nodos: {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 los modelos de GPU y los casos de uso?",
    "¿Cómo se relacionan los precios y las especificaciones de GPU?",
    "¿Qué métodos de despliegue se conectan con qué servicios?",
]

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

---

Ejemplo 5: motor de consultas SQL sobre una 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 una base de datos de ejemplo con datos del mercado de GPU
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 envoltorio 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"],
)

# Consulta 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 40 GB de VRAM",
    "¿Cuál es el precio promedio por hora de los servidores RTX 4090?",
    "¿Qué ubicaciones tienen servidores GPU disponibles?",
    "Enumera 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"📊 Respuesta: {response}")
    if hasattr(response, 'metadata') and 'sql_query' in response.metadata:
        print(f"🔧 SQL: {response.metadata['sql_query']}")

---

Configuración

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

Ajuste	Valor predeterminado	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 mayor 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 (palabras 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

# Combina la 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,  # Genera múltiples variaciones de consulta
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)

3. Re-ranking para calidad

from llama_index.core.postprocessor import SentenceTransformerRerank

# Añade el paso de re-ranking 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,  # Recupera más candidatos
    node_postprocessors=[reranker]  # Reordena al top 3
)

4. Streaming para interfaces de usuario receptivas

# Transmite tokens a medida que se generan
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("Explica cómo funciona Clore.ai")

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

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

Problema: la creación del índice es lenta

# Supervisa el uso de la 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 usa una arquitectura de complementos 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: se superó la ventana de contexto

# Reducir el tamaño de chunk
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# O usa un modelo con un contexto mayor
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # Amplía la ventana de contexto
)

Problema: las consultas devuelven resultados irrelevantes

# Aumenta el top-k de similitud
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

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

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
RAG de producción	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

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