How to Set Up LlamaIndex: A Practical Guide for Enterprise AI Teams

# Install core package (minimal dependencies)
pip install llama-index-core

# Install full suite (includes multi-modal, agents, etc.)
pip install llama-index

# Verify installation
python -c "from llama_index.core import VectorStoreIndex; print('LlamaIndex v0.10.28 ready')"
# Expected output: LlamaIndex v0.10.28 ready

npm install llamaindex
# or
yarn add llamaindex

# Verify installation
node -e "const { VectorStoreIndex } = require('llamaindex'); console.log('LlamaIndex.TS v0.3.12 ready')"
# Expected output: LlamaIndex.TS v0.3.12 ready

from llama_index.core import SimpleDirectoryReader

# Load documents from a directory (supports PDF, DOCX, CSV, etc.)
documents = SimpleDirectoryReader("data/").load_data()
print(f"Loaded {len(documents)} documents")
# Expected output: Loaded 3 documents

# Parse into nodes (chunks with metadata)
from llama_index.core.node_parser import SentenceSplitter
parser = SentenceSplitter(chunk_size=512, chunk_overlap=20)
nodes = parser.get_nodes_from_documents(documents)
print(f"Created {len(nodes)} nodes")
# Expected output: Created 42 nodes

from llama_index.core import VectorStoreIndex

# Create a vector index (uses OpenAI embeddings by default)
index = VectorStoreIndex.from_documents(documents)

# Persist to disk
index.storage_context.persist("storage/")

INFO:llama_index.core.storage.storage_context:Saved VectorStoreIndex to storage/

from llama_index.core import KeywordTableIndex

keyword_index = KeywordTableIndex.from_documents(documents)

from llama_index.core import TreeIndex

tree_index = TreeIndex.from_documents(documents)
# Query with a child-branch traversal
query_engine = tree_index.as_query_engine(child_branch_factor=2)
response = query_engine.query("Summarize the key points")
print(response)

query_engine = index.as_query_engine()
response = query_engine.query("What are the risks of AI in 2026?")
print(response)

The risks of AI in 2026 include:
1. Job displacement in creative industries.
2. Increased misinformation via deepfakes.
3. Regulatory gaps in multi-modal models.
Source: data/report.pdf (page 42)

from llama_index.core import QueryBundle
from llama_index.core.retrievers import BaseRetriever

class HybridRetriever(BaseRetriever):
    def __init__(self, vector_index, keyword_index):
        self.vector_retriever = vector_index.as_retriever()
        self.keyword_retriever = keyword_index.as_retriever()

    def _retrieve(self, query_bundle: QueryBundle):
        vector_nodes = self.vector_retriever.retrieve(query_bundle)
        keyword_nodes = self.keyword_retriever.retrieve(query_bundle)
        return vector_nodes + keyword_nodes

retriever = HybridRetriever(index, keyword_index)
query_engine = index.as_query_engine(retriever=retriever)

from llama_index.core import get_response_synthesizer
from llama_index.core.retrievers import BaseRetriever
from llama_index.core.schema import NodeWithScore
from typing import List

class TimeBasedRetriever(BaseRetriever):
    def __init__(self, index, time_field="date"):
        self.index = index
        self.time_field = time_field

    def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        # Filter nodes by time (e.g., "documents from 2025-2026")
        nodes = self.index.docstore.get_nodes()
        filtered_nodes = [
            node for node in nodes
            if node.metadata.get(self.time_field, "").startswith("2025")
        ]
        return [NodeWithScore(node=node, score=1.0) for node in filtered_nodes]

retriever = TimeBasedRetriever(index)
query_engine = index.as_query_engine(retriever=retriever)

from llama_index.core.evaluation import (
    generate_question_context_pairs,
    EmbeddingQAFinetuneDataset,
)
from llama_index.evaluation import RetrieverEvaluator

# Generate synthetic Q&A pairs
qa_dataset = generate_question_context_pairs(documents, num_questions_per_chunk=2)

# Evaluate retriever
retriever = index.as_retriever(similarity_top_k=2)
evaluator = RetrieverEvaluator.from_metric_names(
    ["mrr", "hit_rate"], retriever=retriever
)
eval_results = await evaluator.aevaluate_dataset(qa_dataset)
print(eval_results)

{'mrr': 0.85, 'hit_rate': 0.92}

from fastapi import FastAPI
from llama_index.core import VectorStoreIndex
from pydantic import BaseModel

app = FastAPI()
index = VectorStoreIndex.from_documents(documents)

class QueryRequest(BaseModel):
    query: str

@app.post("/query")
async def query_index(request: QueryRequest):
    query_engine = index.as_query_engine()
    response = query_engine.query(request.query)
    return {"response": str(response)}

# Run with: uvicorn app:app --reload

{
  "response": "The risks of AI in 2026 include job displacement and misinformation."
}

from llama_index.core.callbacks import CallbackManager
from llama_index.callbacks.arize_ai import ArizeCallbackHandler

arize_callback = ArizeCallbackHandler(
    api_key="...",
    space_key="...",
)
callback_manager = CallbackManager([arize_callback])
index = VectorStoreIndex.from_documents(
    documents, callback_manager=callback_manager
)

from llama_index.indices.managed.llama_cloud import LlamaCloudIndex

index = LlamaCloudIndex.from_documents(
    documents,
    name="my-production-index",
    project_name="my-project",
    api_key="llx-...",
)