Overview
Purpose and Scope
LlamaIndex is documented in this repository as an open source framework for building context-augmented LLM applications: applications where a large language model is connected to private, domain-specific, or application-specific data. The framework documentation describes the product in agent-oriented terms, emphasizing LLM-powered agents over user data and workflows that combine agents, connectors, tools, retrieval, and deployment. This page orients repository readers before they choose a learning path, install packages, or dive into a specific subsystem such as indexing, storage, agents, evaluation, or integrations.
Sources: README.md, docs/src/content/docs/framework/index.md
The central idea is context augmentation. A model may already be fluent in language, but it is not automatically trained on a team’s PDFs, SQL databases, APIs, slide decks, support tickets, or internal knowledge bases. LlamaIndex provides building blocks to ingest that data, parse it, index it, retrieve relevant context, and expose the result through query engines, chat engines, agents, and workflows. Retrieval-Augmented Generation, or RAG, is the most common example, but the documentation frames RAG as one pattern inside a broader framework for data-aware LLM applications.
Sources: docs/src/content/docs/framework/index.md
Relevant Source Files
- README.md — Repository-level landing page for LlamaIndex OSS, including package status badges and community entry points.
- llama-index-core/README.md — Defines the core Python package and names the foundational abstractions used by LLM applications, especially RAG applications.
- llama-index-integrations/README.md — Explains that integrations are separate Python packages categorized by type and used alongside the core package.
- docs/src/content/docs/framework/index.md — First-party framework welcome page that introduces agents, workflows, context augmentation, use cases, getting started, LlamaCloud, community, and related projects.
Repository and Package Model
The repository is organized around a split between a foundational core package and many optional integration packages. The core README describes llama-index-core as the core Python package for the LlamaIndex library. It names the foundational building blocks as abstractions for LLMs, vector stores, embeddings, storage, callables, and other components used to build LLM applications. That framing matters because most user-facing features are composed from stable core contracts rather than hard-coded provider implementations.
Sources: llama-index-core/README.md
Integrations extend those core contracts. The integrations README states that building LLM applications with LlamaIndex involves using core plus the integrations required for a specific application, and that integrations are categorized by type with each integration packaged as its own Python package. In practice, this means a developer should think in two layers: the application code depends on core concepts such as models, indexes, retrievers, tools, and storage, while provider-specific packages supply concrete LLMs, embeddings, readers, vector stores, callbacks, agents, or utility connectors.
Sources: llama-index-core/README.md, llama-index-integrations/README.md
This split is important for both learning and operations. When reading the documentation, start with the core concepts and module guides so the vocabulary is clear, then select integration packages only when the application needs a concrete provider or external service. When maintaining an application, the same split helps isolate choices: changing an embedding provider, vector database, reader, or observability backend should usually be understood as changing an integration behind a core abstraction, not rewriting the whole LlamaIndex workflow.
Sources: llama-index-core/README.md, llama-index-integrations/README.md
Core Primitives
The framework welcome page introduces several primitives that recur throughout the documentation. Agents are LLM-powered knowledge assistants that use tools to perform tasks such as research and data extraction. The same page explains that agents can range from simple question-answering systems to systems that sense, decide, and take actions. LlamaIndex positions RAG pipelines as one kind of tool an agent can use, which helps connect the classic indexing and retrieval path to the newer agent and workflow path.
Sources: docs/src/content/docs/framework/index.md
Workflows are described as multi-step, event-driven processes that combine agents, data connectors, and tools to complete a task. They are the orchestration layer for more complex applications that need reflection, error correction, multiple data sources, or multiple agents. That means workflows are not merely examples around the framework; they are a runtime pattern for composing the same underlying primitives into production-grade behavior. The docs also connect workflows to deployment as production microservices, so readers interested in operations should follow the deployment and runtime pages after understanding the agent model.
Sources: docs/src/content/docs/framework/index.md
Data connectors, data indexes, and engines form the core RAG path. Connectors ingest data from native sources and formats. Indexes structure the data into intermediate representations that are easier and more efficient for LLMs to consume. Engines expose natural-language access to that data, including query and chat experiences. These terms appear across the module guides and API reference, so readers should treat them as shared vocabulary rather than isolated features. A typical application starts with loading, moves through parsing and indexing, and then exposes a query, chat, agent, or workflow interface.
Sources: docs/src/content/docs/framework/index.md
System-to-Code Mapping
| Reader question | Repository-backed answer | Primary source |
|---|---|---|
| What is LlamaIndex for? | Building context-augmented LLM applications and agents over user data. | docs/src/content/docs/framework/index.md |
| What belongs in core? | Foundational abstractions for LLMs, vector stores, embeddings, storage, callables, RAG, and related building blocks. | llama-index-core/README.md |
| What belongs in integrations? | Provider and connector packages categorized by type and installed as separate Python packages when needed. | llama-index-integrations/README.md |
| Where should new readers start? | The framework welcome page, then getting started, concepts, module guides, examples, and relevant integration families. | docs/src/content/docs/framework/index.md |
| How does the repository present community access? | The root README exposes project badges and community links, while the docs welcome page points readers to community and related projects. | README.md, docs/src/content/docs/framework/index.md |
The mapping above is useful because the repository is large and intentionally modular. A new reader can easily mistake the integrations catalog for the framework itself, or assume the framework is only a vector index library. The source-backed model is broader: llama-index-core provides shared abstractions, integrations provide concrete adapters, and the documentation organizes user journeys around context augmentation, RAG, agents, workflows, deployment, evaluation, and community resources.
Sources: README.md, llama-index-core/README.md, llama-index-integrations/README.md, docs/src/content/docs/framework/index.md
Main Documentation Paths
If you are building your first application, begin with installation and the starter example, then read the core concepts primer. That sequence introduces the package model before asking you to choose providers or storage systems. After that, follow the RAG path through documents and nodes, readers, node parsers, ingestion pipelines, indexes, retrievers, query engines, response synthesis, and persistence. This path is best when the main product requirement is to answer questions over a corpus or expose search-like access to private data.
Sources: docs/src/content/docs/framework/index.md, llama-index-core/README.md
If you are building an assistant that acts, not only answers, follow the agent path. Start with the agents overview, then read agent configuration, tools, MCP tools if external tool servers are relevant, multi-agent workflows, human-in-the-loop patterns, channels, sessions, and streaming. The framework welcome page’s definitions of agents and workflows explain why this path branches from core RAG: an agent may use a RAG pipeline as a tool, but it may also coordinate multiple tools, make decisions, and participate in an event-driven workflow.
Sources: docs/src/content/docs/framework/index.md
If you are selecting infrastructure, follow the integration paths after the conceptual pages. LLM integrations and embedding integrations determine the model layer, vector-store integrations determine semantic retrieval storage, data and tool integrations determine how external systems enter the application, and callback or instrumentation integrations determine how behavior is traced and debugged. The integrations README’s package-per-integration model means these choices usually correspond to additional installable packages layered on top of core abstractions.
Sources: llama-index-integrations/README.md, llama-index-core/README.md
Practical Next Steps
For a quick orientation, read the installation page next and confirm whether your application needs only the main package or additional integration packages. Then run the starter example to see documents loaded, indexed, and queried end to end. Once that works, decide whether your application is primarily a RAG system, a conversational interface, an agent, or an event-driven workflow. That decision determines which OpenWiki path to follow and which LlamaIndex abstractions to learn first.
Sources: docs/src/content/docs/framework/index.md, llama-index-core/README.md, llama-index-integrations/README.md
Related pages: Installation, Starter Example, Core Concepts Primer, Readers and Data Loading, Indexes, Query Engines, Agents Overview, Workflows, LLM Integrations, Vector Store Integrations