LlamaIndex - LLM アプリケーション向けデータフレームワーク

LLM とデータを接続する主流フレームワーク。

LlamaIndex を使用する時期

以下の場合に LlamaIndex を使用してください:

• RAG (Retrieval-Augmented Generation) アプリケーションを構築している
• プライベートデータに対するドキュメント質問応答が必要
• 複数のソース (300+ コネクタ) からデータを取り込んでいる
• LLM 用の知識ベースを作成している
• エンタープライズデータを使用したチャットボットを構築している
• ドキュメントから構造化データを抽出する必要がある

メトリクス:

• 45,100+ GitHub スター
• 23,000+ リポジトリ が LlamaIndex を使用
• 300+ データコネクタ (LlamaHub)
• 1,715+ 貢献者
• v0.14.7 (安定版)

代わりに代替案を使用してください:

• LangChain: より汎用的で、エージェントに優れている
• Haystack: 本番環境検索パイプライン
• txtai: 軽量なセマンティック検索
• Chroma: ベクトルストレージだけが必要

クイックスタート

インストール

# スターターパッケージ (推奨)
pip install llama-index

# または最小限のコア + 特定の統合
pip install llama-index-core
pip install llama-index-llms-openai
pip install llama-index-embeddings-openai

5 行の RAG サンプル

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# ドキュメントを読み込む
documents = SimpleDirectoryReader("data").load_data()

# インデックスを作成
index = VectorStoreIndex.from_documents(documents)

# クエリを実行
query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")
print(response)

コアコンセプト

1. データコネクタ - ドキュメントを読み込む

from llama_index.core import SimpleDirectoryReader, Document
from llama_index.readers.web import SimpleWebPageReader
from llama_index.readers.github import GithubRepositoryReader

# ファイルのディレクトリ
documents = SimpleDirectoryReader("./data").load_data()

# Webページ
reader = SimpleWebPageReader()
documents = reader.load_data(["https://example.com"])

# GitHub リポジトリ
reader = GithubRepositoryReader(owner="user", repo="repo")
documents = reader.load_data(branch="main")

# 手動でドキュメントを作成
doc = Document(
    text="This is the document content",
    metadata={"source": "manual", "date": "2025-01-01"}
)

2. インデックス - データを構造化

from llama_index.core import VectorStoreIndex, ListIndex, TreeIndex

# ベクトルインデックス (最も一般的 - セマンティック検索)
vector_index = VectorStoreIndex.from_documents(documents)

# リストインデックス (順序のあるスキャン)
list_index = ListIndex.from_documents(documents)

# ツリーインデックス (階層的な要約)
tree_index = TreeIndex.from_documents(documents)

# インデックスを保存
index.storage_context.persist(persist_dir="./storage")

# インデックスを読み込む
from llama_index.core import load_index_from_storage, StorageContext
storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)

3. クエリエンジン - 質問を質問する

# 基本的なクエリ
query_engine = index.as_query_engine()
response = query_engine.query("What is the main topic?")
print(response)

# ストリーミング応答
query_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)

# カスタム設定
query_engine = index.as_query_engine(
    similarity_top_k=3,          # 上位 3 チャンクを返す
    response_mode="compact",     # または "tree_summarize", "simple_summarize"
    verbose=True
)

4. リトリーバー - 関連チャンクを検索

# ベクトルリトリーバー
retriever = index.as_retriever(similarity_top_k=5)
nodes = retriever.retrieve("machine learning")

# フィルタリング付き
retriever = index.as_retriever(
    similarity_top_k=3,
    filters={"metadata.category": "tutorial"}
)

# カスタムリトリーバー
from llama_index.core.retrievers import BaseRetriever

class CustomRetriever(BaseRetriever):
    def _retrieve(self, query_bundle):
        # カスタム検索ロジック
        return nodes

ツール付きエージェント

基本的なエージェント

from llama_index.core.agent import FunctionAgent
from llama_index.llms.openai import OpenAI

# ツールを定義
def 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

# エージェントを作成
llm = OpenAI(model="gpt-4o")
agent = FunctionAgent.from_tools(
    tools=[multiply, add],
    llm=llm,
    verbose=True
)

# エージェントを使用
response = agent.chat("What is 25 * 17 + 142?")
print(response)

RAG エージェント (ドキュメント検索 + ツール)

from llama_index.core.tools import QueryEngineTool

# 前述のようにインデックスを作成
index = VectorStoreIndex.from_documents(documents)

# クエリエンジンをツールとしてラップ
query_tool = QueryEngineTool.from_defaults(
    query_engine=index.as_query_engine(),
    name="python_docs",
    description="Useful for answering questions about Python programming"
)

# ドキュメント検索 + 計算機を使用したエージェント
agent = FunctionAgent.from_tools(
    tools=[query_tool, multiply, add],
    llm=llm
)

# エージェントはドキュメント検索と計算を決定する
response = agent.chat("According to the docs, what is Python used for?")

高度な RAG パターン

チャットエンジン (会話型)

from llama_index.core.chat_engine import CondensePlusContextChatEngine

# メモリ付きチャット
chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",  # または "context", "react"
    verbose=True
)

# 複数ターンの会話
response1 = chat_engine.chat("What is Python?")
response2 = chat_engine.chat("Can you give examples?")  # コンテキストを覚えている
response3 = chat_engine.chat("What about web frameworks?")

メタデータフィルタリング

from llama_index.core.vector_stores import MetadataFilters, ExactMatchFilter

# メタデータでフィルタリング
filters = 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 BaseModel
from llama_index.core.output_parsers import PydanticOutputParser

class Summary(BaseModel):
    title: str
    main_points: list[str]
    conclusion: str

# 構造化された応答を取得
output_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 モデル
print(summary.title, summary.main_points)

データ取り込みパターン

複数のファイル形式

# サポートされているすべての形式を読み込む
documents = SimpleDirectoryReader(
    "./data",
    recursive=True,
    required_exts=[".pdf", ".docx", ".txt", ".md"]
).load_data()

Web スクレイピング

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

API エンドポイント

from llama_index.readers.json import JSONReader

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

ベクトルストア統合

Chroma (ローカル)

from llama_index.vector_stores.chroma import ChromaVectorStore
import chromadb

# Chroma を初期化
db = chromadb.PersistentClient(path="./chroma_db")
collection = db.get_or_create_collection("my_collection")

# ベクトルストアを作成
vector_store = ChromaVectorStore(chroma_collection=collection)

# インデックスで使用
from llama_index.core import StorageContext
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

Pinecone (クラウド)

from llama_index.vector_stores.pinecone import PineconeVectorStore
import pinecone

# Pinecone を初期化
pinecone.init(api_key="your-key", environment="us-west1-gcp")
pinecone_index = pinecone.Index("my-index")

# ベクトルストアを作成
vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

FAISS (高速)

from llama_index.vector_stores.faiss import FaissVectorStore
import faiss

# FAISS インデックスを作成
d = 1536  # エンベディングの次元
faiss_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)

カスタマイズ

カスタム LLM

from llama_index.llms.anthropic import Anthropic
from llama_index.core import Settings

# グローバル LLM を設定
Settings.llm = Anthropic(model="claude-sonnet-4-5-20250929")

# これですべてのクエリが Anthropic を使用
query_engine = index.as_query_engine()

カスタムエンベディング

from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# HuggingFace エンベディングを使用
Settings.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)

マルチモーダル RAG

画像 + テキスト

from llama_index.core import SimpleDirectoryReader
from llama_index.multi_modal_llms.openai import OpenAIMultiModal

# 画像とドキュメントを読み込む
documents = SimpleDirectoryReader(
    "./data",
    required_exts=[".jpg", ".png", ".pdf"]
).load_data()

# マルチモーダルインデックス
index = VectorStoreIndex.from_documents(documents)

# マルチモーダル LLM でクエリ
multi_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

# 関連性を評価
relevancy = RelevancyEvaluator()
result = relevancy.evaluate_response(
    query="What is Python?",
    response=response
)
print(f"Relevancy: {result.passing}")

# 忠実性を評価 (幻覚がない)
faithfulness = FaithfulnessEvaluator()
result = faithfulness.evaluate_response(
    query="What is Python?",
    response=response
)
print(f"Faithfulness: {result.passing}")

ベストプラクティス

1. ほとんどの場合ベクトルインデックスを使用する - 最高のパフォーマンス
2. インデックスをディスクに保存 - 再インデックス化を回避
3. ドキュメントを適切にチャンク化 - 512～1024 トークンが最適
4. メタデータを追加 - フィルタリングと追跡を可能にする
5. ストリーミングを使用 - 長い応答の UX を改善
6. 開発中は詳細モードを有効にする - 検索プロセスを確認
7. 応答を評価する - 関連性と忠実性を確認
8. 会話にはチャットエンジンを使用 - 組み込みメモリ
9. ストレージを永続化 - インデックスを失わない
10. コストを監視 - エンベディングと LLM 使用量を追跡

一般的なパターン

ドキュメント Q&A システム

# 完全な RAG パイプライン
documents = SimpleDirectoryReader("docs").load_data()
index = VectorStoreIndex.from_documents(documents)
index.storage_context.persist(persist_dir="./storage")

# クエリ
query_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]}")

メモリ付きチャットボット

# 会話型インターフェース
chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",
    verbose=True
)

# 複数ターンのチャット
while True:
    user_input = input("You: ")
    if user_input.lower() == "quit":
        break
    response = chat_engine.chat(user_input)
    print(f"Bot: {response}")

パフォーマンスベンチマーク

操作	レイテンシ	注釈
100 ドキュメントのインデックス化	~10-30 秒	1 回限り、永続化可能
クエリ (ベクトル)	~0.5-2 秒	検索 + LLM
ストリーミングクエリ	~0.5 秒最初のトークン	UX の向上
ツール付きエージェント	~3-8 秒	複数のツール呼び出し

LlamaIndex vs LangChain

機能	LlamaIndex	LangChain
最適な用途	RAG、ドキュメント Q&A	エージェント、汎用 LLM アプリ
データコネクタ	300+ (LlamaHub)	100+
RAG 対応	コア機能	多くの機能の 1 つ
学習曲線	RAG は簡単	より急峻
カスタマイズ	高	非常に高
ドキュメント	優れている	良好

以下の場合に LlamaIndex を使用:

• 主なユースケースが RAG
• 多くのデータコネクタが必要
• ドキュメント Q&A にはシンプルな API が必要
• 知識検索システムを構築している

以下の場合に LangChain を使用:

• 複雑なエージェントを構築している
• より汎用的なツールが必要
• より多くの柔軟性が必要
• 複雑な複数ステップのワークフロー

参考資料

• Query Engines Guide - クエリモード、カスタマイズ、ストリーミング
• Agents Guide - ツール作成、RAG エージェント、複数ステップ推論
• Data Connectors Guide - 300+ コネクタ、カスタムローダー

リソース

• GitHub: https://github.com/run-llama/llama_index ⭐ 45,100+
• Docs: https://developers.llamaindex.ai/python/framework/
• LlamaHub: https://llamahub.ai (データコネクタ)
• LlamaCloud: https://cloud.llamaindex.ai (エンタープライズ)
• Discord: https://discord.gg/dGcwcsnxhU
• バージョン: 0.14.7+
• ライセンス: MIT