> 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-es/rag-y-bases-de-datos-vectoriales/llamaindex.md).

# 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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

***

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

{% hint style="info" %}
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.
{% endhint %}

***

## Despliegue rápido en CLORE.AI

### 1. Encuentra un servidor adecuado

Ve a [Marketplace de CLORE.AI](https://clore.ai/marketplace) 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:**

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

```bash
ssh root@<la-ip-de-tu-servidor-clore> -p <puerto-ssh>
```

### Paso 2: instala Ollama

```bash
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

```bash
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

```bash
# 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

```python
# 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

```python
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

```python
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

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

# 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

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

# 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

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

# 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

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

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

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

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

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

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

# 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

```python
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

```python
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```python
# 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

```python
# 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](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# 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-es/rag-y-bases-de-datos-vectoriales/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.