LlamaIndex Settings — global vs per-object LLM and embed_model

from llama_index.core import VectorStoreIndex, Settings
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI
from llama_index.llms.anthropic import Anthropic

# --- Bad: relies on global Settings ---
# Settings.llm = OpenAI(model="gpt-4o")
# Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
# index = VectorStoreIndex.from_documents(docs)
# query_engine = index.as_query_engine()

# --- Good: explicit models ---
embed_model = OpenAIEmbedding(model="text-embedding-3-small")
main_llm = OpenAI(model="gpt-4o-mini")

index = VectorStoreIndex.from_documents(
    docs,
    embed_model=embed_model,     # ← explicit
)

# Use different LLMs for different query engines
fast_engine = index.as_query_engine(
    llm=OpenAI(model="gpt-4o-mini"),
    embed_model=embed_model,
    similarity_top_k=6,
)

quality_engine = index.as_query_engine(
    llm=OpenAI(model="gpt-4o"),
    embed_model=embed_model,
    similarity_top_k=10,
    response_mode="tree_summarize",
)

# Per-tenant / per-request LLM
def get_engine_for_tenant(tenant_id: str, index):
    tenant_llm = load_tenant_llm(tenant_id)     # your logic
    return index.as_query_engine(
        llm=tenant_llm,
        embed_model=embed_model,
        similarity_top_k=6,
    )

# Multi-model comparison
alt_engine = index.as_query_engine(
    llm=Anthropic(model="claude-sonnet-5"),
    embed_model=embed_model,
)

from fastapi import FastAPI
from llama_index.core import Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

app = FastAPI()

# --- App startup: set default Settings ONCE ---
@app.on_event("startup")
async def init_settings():
    Settings.llm = OpenAI(model="gpt-4o-mini")
    Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
    # Never mutated again after this

# --- Per-tenant config resolved per-request ---
def get_tenant_llm(tenant_id: str):
    # Look up tenant-specific LLM (API key, model choice)
    return OpenAI(
        api_key=fetch_tenant_key(tenant_id),
        model=fetch_tenant_model(tenant_id, default="gpt-4o-mini"),
    )

@app.post("/chat/{tenant_id}")
async def chat(tenant_id: str, message: str):
    # DO NOT: Settings.llm = get_tenant_llm(tenant_id)  ← global mutation
    # DO: use per-request llm explicitly
    tenant_llm = get_tenant_llm(tenant_id)
    tenant_index = load_tenant_index(tenant_id)
    query_engine = tenant_index.as_query_engine(llm=tenant_llm)
    return {"response": str(query_engine.query(message))}


# --- Multi-worker gunicorn / uvicorn ---
# Each worker has its OWN Settings singleton — so worker-level Settings.llm
# is fine, but do not mutate at request time.

# conftest.py — reset Settings state between tests
import pytest
from llama_index.core import Settings
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI

@pytest.fixture(autouse=True)
def reset_llamaindex_settings():
    """Snapshot Settings before each test, restore after."""
    snapshot = {
        "llm": Settings.llm,
        "embed_model": Settings.embed_model,
        "node_parser": Settings.node_parser,
        "chunk_size": Settings.chunk_size,
        "chunk_overlap": Settings.chunk_overlap,
    }
    try:
        yield
    finally:
        Settings.llm = snapshot["llm"]
        Settings.embed_model = snapshot["embed_model"]
        Settings.node_parser = snapshot["node_parser"]
        Settings.chunk_size = snapshot["chunk_size"]
        Settings.chunk_overlap = snapshot["chunk_overlap"]


# In a specific test that needs a custom LLM
def test_custom_llm(reset_llamaindex_settings):
    Settings.llm = OpenAI(model="gpt-3.5-turbo")
    # ... test logic ...
    # After the test, Settings is restored automatically


# For unit tests, prefer FakeLLM and MockEmbedding
from llama_index.core.llms.mock import MockLLM
from llama_index.core.embeddings.mock_embed_model import MockEmbedding

def test_query_engine_logic():
    mock_llm = MockLLM(max_tokens=100)
    mock_embed = MockEmbedding(embed_dim=1536)

    # Pass explicitly — never rely on Settings in tests
    index = VectorStoreIndex.from_documents(
        docs, llm=mock_llm, embed_model=mock_embed,
    )
    query_engine = index.as_query_engine(llm=mock_llm, embed_model=mock_embed)
    response = query_engine.query("test")
    assert response