LlamaIndex Integration

pip install openinference-instrumentation-llama-index llama-index>=0.11.0

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
import os

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "your-api-key"

# Load documents and create index
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# Query the index - automatically traced!
query_engine = index.as_query_engine()
response = query_engine.query("What are the key insights from the documents?")
print(response)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.postprocessor import SimilarityPostprocessor

# Load and index documents
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# Configure retriever with custom parameters
retriever = VectorIndexRetriever(
    index=index,
    similarity_top_k=10,  # Retrieve top 10 documents
)

# Add post-processing to filter by similarity
response_synthesizer = index.as_query_engine().response_synthesizer
query_engine = RetrieverQueryEngine(
    retriever=retriever,
    response_synthesizer=response_synthesizer,
    node_postprocessors=[
        SimilarityPostprocessor(similarity_cutoff=0.7)
    ]
)

# Phoenix traces the entire retrieval pipeline
response = query_engine.query("What is Phoenix?")
print(response)

from llama_index.core.agent import ReActAgent
from llama_index.core.tools import FunctionTool
from llama_index.llms.openai import OpenAI

def multiply(a: float, b: float) -> float:
    """Multiply two numbers and return the result."""
    return a * b

def add(a: float, b: float) -> float:
    """Add two numbers and return the result."""
    return a + b

# Create tools
multiply_tool = FunctionTool.from_defaults(fn=multiply)
add_tool = FunctionTool.from_defaults(fn=add)

# Create agent
llm = OpenAI(model="gpt-4")
agent = ReActAgent.from_tools(
    [multiply_tool, add_tool],
    llm=llm,
    verbose=True
)

# Phoenix traces the agent's reasoning and tool usage
response = agent.chat("What is (5 + 3) * 4?")
print(response)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.core.query_engine import SubQuestionQueryEngine

# Load documents for different topics
phoenix_docs = SimpleDirectoryReader("phoenix_docs").load_data()
llamaindex_docs = SimpleDirectoryReader("llamaindex_docs").load_data()

# Create separate indexes
phoenix_index = VectorStoreIndex.from_documents(phoenix_docs)
llamaindex_index = VectorStoreIndex.from_documents(llamaindex_docs)

# Create query engine tools
phoenix_engine = phoenix_index.as_query_engine()
llamaindex_engine = llamaindex_index.as_query_engine()

query_engine_tools = [
    QueryEngineTool(
        query_engine=phoenix_engine,
        metadata=ToolMetadata(
            name="phoenix_docs",
            description="Information about Phoenix observability"
        ),
    ),
    QueryEngineTool(
        query_engine=llamaindex_engine,
        metadata=ToolMetadata(
            name="llamaindex_docs",
            description="Information about LlamaIndex framework"
        ),
    ),
]

# Create sub-question query engine
query_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=query_engine_tools,
)

# Phoenix traces the decomposed questions and synthesis
response = query_engine.query(
    "How can I use Phoenix with LlamaIndex to monitor my RAG application?"
)
print(response)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine(streaming=True)

# Stream the response
response = query_engine.query("Summarize the key points")
for text in response.response_gen:
    print(text, end="", flush=True)

# Phoenix captures the full streamed response

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.memory import ChatMemoryBuffer

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# Create chat engine with memory
memory = ChatMemoryBuffer.from_defaults(token_limit=3000)
chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",
    memory=memory,
    verbose=True
)

# Phoenix traces the conversation context
response = chat_engine.chat("What is this document about?")
print(response)

response = chat_engine.chat("Tell me more about that topic")
print(response)