# LlamaIndex

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](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 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)                |

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

***

## Despliegue rápido en CLORE.AI

### 1. Encuentra un servidor adecuado

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

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

# 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

```bash
ssh root@<tu-ip-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
# 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

```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: Construye tu primer índice

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

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

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

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

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

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

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

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

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

# 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

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

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

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

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

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

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

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


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/llamaindex.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.