Querying Your Indexed Data

Now that you have successfully loaded your external data and structured it into a LlamaIndex index, the next logical step is to retrieve information from it. Simply indexing data isn't useful on its own; the goal is to ask questions and get relevant answers grounded in that specific data. This is where LlamaIndex's querying capabilities come into play.

The Query Engine Interface

The primary way to interact with your indexed data in LlamaIndex is through a QueryEngine. Think of the query engine as the component responsible for taking your natural language question, searching the index for the most relevant pieces of information (Nodes), and then synthesizing a coherent answer, typically using an LLM.

Creating a basic query engine from an existing index is straightforward. If you have an index object (created as shown in the previous sections on indexing), you can instantiate a query engine like this:

# Assuming 'index' is your previously created LlamaIndex Index object
query_engine = index.as_query_engine()

This simple call sets up a default query engine with sensible configurations suitable for many common use cases.

Performing a Query

Once you have a query_engine object, asking a question is as simple as calling its query method:

# Ask a question about the indexed data
response = query_engine.query("What were the main findings of the research paper?")

# Print the textual response synthesized by the LLM
print(response.response)

The query method takes your question as a string argument. Under the hood, LlamaIndex performs several steps:

1. Retrieve: It searches the index (often using vector embeddings and similarity search) to find the Nodes containing information most relevant to your query.
2. Synthesize: It takes the retrieved Nodes (the context) and your original query, feeding them to an LLM to generate a natural language answer.

This retrieve-then-synthesize pattern is the foundation of Retrieval-Augmented Generation (RAG), a technique we will explore in more detail in the next chapter.

Understanding the Response

The object returned by the query method contains more than just the final text answer. It typically provides valuable metadata about the query process.

# Accessing the response text
print(f"Response Text:\n{response.response}\n")

# Accessing the source nodes used for the response
print("Source Nodes:")
for node in response.source_nodes:
    print(f"  Node ID: {node.node_id}")
    print(f"  Similarity Score: {node.score:.4f}")
    # Displaying a snippet of the source text
    print(f"  Text Snippet: {node.text[:150]}...")
    print("-" * 20)

The two most important attributes are usually:

• response.response (or response.response_txt in some versions): This attribute holds the string containing the final synthesized answer generated by the LLM based on the retrieved context.
• response.source_nodes: This is a list of NodeWithScore objects. Each object represents a chunk of data retrieved from your index that was used as context to generate the answer. Inspecting these nodes is extremely useful for:
  • Transparency: Understanding why the LLM gave a particular answer.
  • Debugging: Identifying if the retrieval step fetched irrelevant information or missed important context.
  • Verification: Allowing users or developers to trace the answer back to the original source documents.

Each NodeWithScore object within source_nodes typically contains:

• node: The actual TextNode (or other node type) object, including its text content (node.text) and metadata.
• score: A numerical score (often a similarity score from the vector search) indicating how relevant the node was deemed to the query during the retrieval phase. Higher scores usually indicate greater relevance.

Here is a diagram illustrating the basic query flow:

The query process involves the query engine searching the index, retrieving relevant nodes, and using an LLM to synthesize an answer based on the query and the retrieved context.

Configuration and Customization

While index.as_query_engine() provides a convenient starting point, LlamaIndex offers extensive customization options for query engines. You can configure aspects like:

• The number of nodes to retrieve (similarity_top_k).
• The specific LLM used for synthesis.
• The response mode (how the LLM uses the retrieved context).
• Filtering based on node metadata.

These advanced configurations allow you to fine-tune the retrieval and synthesis process for better performance and relevance on specific tasks, which we will touch upon when discussing RAG systems.

For now, the ability to create a default query engine and inspect both the synthesized response and the source nodes provides a powerful mechanism for leveraging your indexed external data within LLM applications. The next step is to integrate this capability into more complex workflows and build full-fledged RAG pipelines.