Llamaindex

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
# Load documentsdocuments = SimpleDirectoryReader("data").load_data()
# Create indexindex = VectorStoreIndex.from_documents(documents)
# Queryquery_engine = index.as_query_engine()response = query_engine.query("What did the author do growing up?")print(response)

from llama_index.core import SimpleDirectoryReader, Documentfrom llama_index.readers.web import SimpleWebPageReaderfrom llama_index.readers.github import GithubRepositoryReader
# Directory of filesdocuments = SimpleDirectoryReader("./data").load_data()
# Web pagesreader = SimpleWebPageReader()documents = reader.load_data(["https://example.com"])
# GitHub repositoryreader = GithubRepositoryReader(owner="user", repo="repo")documents = reader.load_data(branch="main")
# Manual document creationdoc = Document(    text="This is the document content",    metadata={"source": "manual", "date": "2025-01-01"})

from llama_index.core import VectorStoreIndex, ListIndex, TreeIndex
# Vector index (most common - semantic search)vector_index = VectorStoreIndex.from_documents(documents)
# List index (sequential scan)list_index = ListIndex.from_documents(documents)
# Tree index (hierarchical summary)tree_index = TreeIndex.from_documents(documents)
# Save indexindex.storage_context.persist(persist_dir="./storage")
# Load indexfrom llama_index.core import load_index_from_storage, StorageContextstorage_context = StorageContext.from_defaults(persist_dir="./storage")index = load_index_from_storage(storage_context)

# Basic queryquery_engine = index.as_query_engine()response = query_engine.query("What is the main topic?")print(response)
# Streaming responsequery_engine = index.as_query_engine(streaming=True)response = query_engine.query("Explain quantum computing")for text in response.response_gen:    print(text, end="", flush=True)
# Custom configurationquery_engine = index.as_query_engine(    similarity_top_k=3,          # Return top 3 chunks    response_mode="compact",     # Or "tree_summarize", "simple_summarize"    verbose=True)

# Vector retrieverretriever = index.as_retriever(similarity_top_k=5)nodes = retriever.retrieve("machine learning")
# With filteringretriever = index.as_retriever(    similarity_top_k=3,    filters={"metadata.category": "tutorial"})
# Custom retrieverfrom llama_index.core.retrievers import BaseRetriever
class CustomRetriever(BaseRetriever):    def _retrieve(self, query_bundle):        # Your custom retrieval logic        return nodes

from llama_index.core.agent import FunctionAgentfrom llama_index.llms.openai import OpenAI
# Define toolsdef multiply(a: int, b: int) -> int:    """Multiply two numbers."""    return a * b
def add(a: int, b: int) -> int:    """Add two numbers."""    return a + b
# Create agentllm = OpenAI(model="gpt-4o")agent = FunctionAgent.from_tools(    tools=[multiply, add],    llm=llm,    verbose=True)
# Use agentresponse = agent.chat("What is 25 * 17 + 142?")print(response)

from llama_index.core.tools import QueryEngineTool
# Create index as beforeindex = VectorStoreIndex.from_documents(documents)
# Wrap query engine as toolquery_tool = QueryEngineTool.from_defaults(    query_engine=index.as_query_engine(),    name="python_docs",    description="Useful for answering questions about Python programming")
# Agent with document search + calculatoragent = FunctionAgent.from_tools(    tools=[query_tool, multiply, add],    llm=llm)
# Agent decides when to search docs vs calculateresponse = agent.chat("According to the docs, what is Python used for?")

from llama_index.core.chat_engine import CondensePlusContextChatEngine
# Chat with memorychat_engine = index.as_chat_engine(    chat_mode="condense_plus_context",  # Or "context", "react"    verbose=True)
# Multi-turn conversationresponse1 = chat_engine.chat("What is Python?")response2 = chat_engine.chat("Can you give examples?")  # Remembers contextresponse3 = chat_engine.chat("What about web frameworks?")

from llama_index.core.vector_stores import MetadataFilters, ExactMatchFilter
# Filter by metadatafilters = MetadataFilters(    filters=[        ExactMatchFilter(key="category", value="tutorial"),        ExactMatchFilter(key="difficulty", value="beginner")    ])
retriever = index.as_retriever(    similarity_top_k=3,    filters=filters)
query_engine = index.as_query_engine(filters=filters)

from pydantic import BaseModelfrom llama_index.core.output_parsers import PydanticOutputParser
class Summary(BaseModel):    title: str    main_points: list[str]    conclusion: str
# Get structured responseoutput_parser = PydanticOutputParser(output_cls=Summary)query_engine = index.as_query_engine(output_parser=output_parser)
response = query_engine.query("Summarize the document")summary = response  # Pydantic modelprint(summary.title, summary.main_points)

# Load all supported formatsdocuments = SimpleDirectoryReader(    "./data",    recursive=True,    required_exts=[".pdf", ".docx", ".txt", ".md"]).load_data()

from llama_index.readers.web import BeautifulSoupWebReader
reader = BeautifulSoupWebReader()documents = reader.load_data(urls=[    "https://docs.python.org/3/tutorial/",    "https://docs.python.org/3/library/"])

from llama_index.readers.database import DatabaseReader
reader = DatabaseReader(    sql_database_uri="postgresql://user:pass@localhost/db")documents = reader.load_data(query="SELECT * FROM articles")

from llama_index.readers.json import JSONReader
reader = JSONReader()documents = reader.load_data("https://api.example.com/data.json")

from llama_index.vector_stores.chroma import ChromaVectorStoreimport chromadb
# Initialize Chromadb = chromadb.PersistentClient(path="./chroma_db")collection = db.get_or_create_collection("my_collection")
# Create vector storevector_store = ChromaVectorStore(chroma_collection=collection)
# Use in indexfrom llama_index.core import StorageContextstorage_context = StorageContext.from_defaults(vector_store=vector_store)index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

from llama_index.vector_stores.pinecone import PineconeVectorStoreimport pinecone
# Initialize Pineconepinecone.init(api_key="your-key", environment="us-west1-gcp")pinecone_index = pinecone.Index("my-index")
# Create vector storevector_store = PineconeVectorStore(pinecone_index=pinecone_index)storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

from llama_index.vector_stores.faiss import FaissVectorStoreimport faiss
# Create FAISS indexd = 1536  # Dimension of embeddingsfaiss_index = faiss.IndexFlatL2(d)
vector_store = FaissVectorStore(faiss_index=faiss_index)storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

from llama_index.llms.anthropic import Anthropicfrom llama_index.core import Settings
# Set global LLMSettings.llm = Anthropic(model="claude-sonnet-4-5-20250929")
# Now all queries use Anthropicquery_engine = index.as_query_engine()

from llama_index.embeddings.huggingface import HuggingFaceEmbedding
# Use HuggingFace embeddingsSettings.embed_model = HuggingFaceEmbedding(    model_name="sentence-transformers/all-mpnet-base-v2")
index = VectorStoreIndex.from_documents(documents)

from llama_index.core import PromptTemplate
qa_prompt = PromptTemplate(    "Context: {context_str}\n"    "Question: {query_str}\n"    "Answer the question based only on the context. "    "If the answer is not in the context, say 'I don't know'.\n"    "Answer: ")
query_engine = index.as_query_engine(text_qa_template=qa_prompt)

from llama_index.core import SimpleDirectoryReaderfrom llama_index.multi_modal_llms.openai import OpenAIMultiModal
# Load images and documentsdocuments = SimpleDirectoryReader(    "./data",    required_exts=[".jpg", ".png", ".pdf"]).load_data()
# Multi-modal indexindex = VectorStoreIndex.from_documents(documents)
# Query with multi-modal LLMmulti_modal_llm = OpenAIMultiModal(model="gpt-4o")query_engine = index.as_query_engine(llm=multi_modal_llm)
response = query_engine.query("What is in the diagram on page 3?")

from llama_index.core.evaluation import RelevancyEvaluator, FaithfulnessEvaluator
# Evaluate relevancerelevancy = RelevancyEvaluator()result = relevancy.evaluate_response(    query="What is Python?",    response=response)print(f"Relevancy: {result.passing}")
# Evaluate faithfulness (no hallucination)faithfulness = FaithfulnessEvaluator()result = faithfulness.evaluate_response(    query="What is Python?",    response=response)print(f"Faithfulness: {result.passing}")

# Complete RAG pipelinedocuments = SimpleDirectoryReader("docs").load_data()index = VectorStoreIndex.from_documents(documents)index.storage_context.persist(persist_dir="./storage")
# Queryquery_engine = index.as_query_engine(    similarity_top_k=3,    response_mode="compact",    verbose=True)response = query_engine.query("What is the main topic?")print(response)print(f"Sources: {[node.metadata['file_name'] for node in response.source_nodes]}")

# Conversational interfacechat_engine = index.as_chat_engine(    chat_mode="condense_plus_context",    verbose=True)
# Multi-turn chatwhile True:    user_input = input("You: ")    if user_input.lower() == "quit":        break    response = chat_engine.chat(user_input)    print(f"Bot: {response}")