A Beginner's Guide to LlamaIndex!
Tags: beginners, ai, tutorial, datascience
Published: 2023-11-03 12:26:16

[Large Language Models](https://thenewstack.io/top-5-large-language-models-and-how-to-use-them-effectively/) (LLMs) like OpenAI's GPT-3 and GPT-4 utilize neural networks with millions to billions of parameters to understand and produce human-like text. Trained on vast datasets from the internet, books and more, they identify patterns in language to deliver contextually appropriate responses. Capable of tasks including translation, summarization and creative writing, these models —despite their sophisticated output — lack consciousness, understanding and emotions. While LLMs can do a vast amount of cool things, they also have some limitations. Today, we will see some enhanced gen AI frameworks that help you remove these limitations.

## What is LlamaIndex?

![what is LlamaIndex](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d65ea3fmkwc77nivns6d.png)

LlamaIndex is an advanced orchestration framework designed to amplify the capabilities of LLMs like GPT-4. While LLMs are inherently powerful, having been trained on vast public datasets, they often lack the means to interact with private or domain-specific data. 

LlamaIndex bridges this gap, offering a structured way to ingest, organize and harness various data sources — including APIs, databases and PDFs. By indexing this data into formats optimized for LLMs, LlamaIndex facilitates natural language querying, enabling users to seamlessly converse with their private data without the need to retrain the models. 

This framework is versatile, catering to both novices with a high-level API for quick setup, and experts seeking in-depth customization through lower-level APIs. In essence, LlamaIndex unlocks the full potential of LLMs, making them more accessible and applicable to individualized data needs.

## How LlamaIndex works
LlamaIndex serves as a bridge, connecting the powerful capabilities of LLMs with diverse data sources, thereby unlocking a new realm of applications that can leverage the synergy between [custom data and advanced language models](https://www.singlestore.com/blog/using-singlestoredb-chatgpt-for-custom-data-sets/). By offering tools for data ingestion, indexing and a natural language query interface, LlamaIndex empowers developers and businesses to build robust, data-augmented applications that significantly enhance decision-making and user engagement.

![working of LlamaIndex](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/u4w04bvnyk8a9747ssx4.png)

LlamaIndex operates through a systematic workflow that starts with a set of documents. Initially, these documents undergo a load process where they are imported into the system. Post loading, the data is parsed to analyze and structure the content in a comprehensible manner. Once parsed, the information is then indexed for optimal retrieval and storage. 

This indexed data is securely stored in a central repository labeled "store". When a user or system wishes to retrieve specific information from this data store, they can initiate a query. In response to the query, the relevant data is extracted and delivered as a response, which might be a set of relevant documents or specific information drawn from them. The entire process showcases how LlamaIndex efficiently manages and retrieves data, ensuring quick and accurate responses to user queries.

Take a look at this enlightening webinar on "[How to Build a Gen AI App with LlamaIndex](https://www.singlestore.com/resources/webinar-how-to-build-a-genai-app-with-llama-index/)." Dive deep into the world of LLMs and discover the critical role LlamaIndex plays in enhancing their capabilities. This session will not only provide theoretical insights but will also include a hands-on technical demonstration.

## Key features of LlamaIndex
LlamaIndex is positioned to significantly enhance the utility and versatility of LLMs. To understand it better, let's break down its features and implications:

- **Diverse data source compatibility** 
Its ability to integrate various data sources — from files to databases and applications — makes it universally applicable across industries and use-cases.

- **Array of connectors** 
With built-in connectors for data ingestion developers can rapidly and effortlessly bridge their data with LLMs, eliminating the need for bespoke integration solutions.

- **Efficient data retrieval** 
An advanced query interface ensures that developers and users get the most relevant information in response to their queries.

- **Customizable indexing** 
By offering multiple indexing options, LlamaIndex ensures that the system can be optimized for specific data types and query needs — enhancing both speed and accuracy.

## LlamaIndex core functionalities + applications
This framework is essential for developers and enterprises looking to leverage the capabilities of LLMs in conjunction with their unique data sets. Here are the key aspects and potential applications of LlamaIndex:

- **Data ingestion** 
LlamaIndex allows for the connection of existing data sources in various formats (APIs, PDFs, documents, SQL, etc.) to LLM applications.

- **Data indexing** 
It provides the tools necessary to store and index data for different use cases, integrating with downstream vector store and database providers.

- **Query interface** 
LlamaIndex offers a query interface that takes any input prompt over the data, returning a knowledge-augmented response.

## Applications of LlamaIndex
Document Q+A. LlamaIndex can be used to build applications that retrieve answers from unstructured data like PDFs, PPTs, web pages and images.

- **Data augmented chatbots** 
It facilitates the creation of chatbots that can converse over a knowledge corpus.

- **Knowledge agents** 
LlamaIndex helps with indexing a knowledge base and task list to build automated decision machines.

- **Structured analytics** 
Users can query their structured data warehouse using natural language2.

Take a look at this wonderful [webinar to learn how to build a GenAI app with LlamaIndex](https://www.singlestore.com/resources/webinar-how-to-build-a-genai-app-with-llama-index/). 

## Real-world use cases of LlamaIndex
Let's take a look at some real-world use cases around LlamaIndex. 

- **Analyzing financial reports** 
LlamaIndex can be used in conjunction with OpenAI to analyze financial reports for entities (like government agencies) for different fiscal years.

- **Building query engines** 
In one case, LlamaIndex was combined with Ray to build a powerful query engine, showcasing a data ingestion and embedding pipeline.

- **Knowledge agents for business** 
LlamaIndex can be utilized to create knowledge agents that undergo specialized training on custom knowledge, making them experts in specific areas.

- **Academic research** 
Researchers can use LlamaIndex to build Retrieval-Augmented Generation (RAG)-based applications to efficiently manage and extract information from numerous research papers and articles in PDF format.

### LangChain vs. LlamaIndex: Key differences to note 
While both [LangChain](https://www.langchain.com/) and LlamaIndex are rooted in language processing using AI and ML, their core objectives differ. LangChain is versatile and foundational, allowing for a broader range of applications. In contrast, LlamaIndex, with its unique approach to document search and summarization, can be seen as a specialized tool — potentially building upon frameworks like LangChain to deliver its unique features.

The following is a comparison overview between LangChain and LlamaIndex.
![LangChain vs LlamaIndex](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4mu19z9xq541v9u1kwq9.png)

### LlamaIndex: A quick tutorial
Let’s try and understand how indexing and querying textual dataworks practically with LlamaIndex.

#### Step 1. Setting up.

Clone the LlamaIndex repository

```
git clone https://github.com/jerryjliu/llama_index.git
```

Navigate to the repository

```
cd llama_index
```

Install the LlamaIndex module. This will install the necessary Python package to your environment.

```
pip install .
```

Install required dependencies

```
pip install -r requirements.txt
```

#### Step 2. Choose an example dataset

For this tutorial, we will use a provided dataset — but LlamaIndex can handle any set of text documents you'd like to index.

Navigate to a specific example dataset:

```
cd examples/paul_graham_essay
```

#### Step 3: Building and querying the index
Create a Python script, let's name it llama_tutorial.py and add the following code to it: 

```
from llama_index import VectorStoreIndex, SimpleDirectoryReader

# Load the documents
documents = SimpleDirectoryReader('data').load_data()

# Build an index over the documents
index = VectorStoreIndex.from_documents(documents)

# Create a query engine
query_engine = index.as_query_engine()

# Run a sample query
response = query_engine.query("What is the main topic of the essay?")

# Print the result
print(response)
```

#### Step 4: Set the Open API key

```
export OPENAI_API_KEY='YOUR_API_KEY_HERE'
```

#### Step 5: Run the script

```
python3 llama_tutorial.py
```

Once you run the script, you should see the output as shown here: 
![LlamaIndex articletutorial](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qmn8kzx3n702x3whr7t3.png)

You can ask different questions/queries and receive accurate answers. 

Armed with the foundational understanding from this article and tutorial, you're now poised to explore the deeper capabilities of LlamaIndex, unlocking the power of advanced textual data indexing and querying.

### LlamaIndex and SingleStoreDB 
LlamaIndex, as described, is an orchestration framework that enhances the capabilities of LLMs (like GPT-4) by allowing them to interact with private or domain-specific data. SingleStoreDB is a distributed, relational database known for its real-time analytics capabilities and hybrid transactional-analytical processing. SingleStoreDB can serve as the primary data storage for LlamaIndex. 

Given its ability to handle both transactions and analytics swiftly, SingleStoreDB would be an excellent choice for users who want real-time insights from their data. When paired with the natural language querying of LlamaIndex, users can ask complex business or analytical questions and receive insights instantly.

![sql database](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jfjdr1o243xi77g5ojl5.png) _**Image idea & credits: LlamaIndex Twitter**_

Both LlamaIndex and SingleStore are designed with scalability in mind. As the data grows or the demand for LLM's insights increases, SingleStoreDB's distributed nature can handle the load, ensuring that users get consistent performance. In this quick LlamaIndex and SingleStoreDB tutorial, our senior technical evangelist Akmal Chaudhri has demonstrated how the two can be a powerful combo. 

### LlamaIndex & SingleStore Tutorial:
#### Prerequisites
- A free [SingleStore cloud account](https://www.singlestore.com/cloud-trial/?utm_medium=referral&utm_source=pavan&utm_term=devto&utm_content=llamadevto)
- Basic knowledge of Python programming
- Understanding of SQL databases
- Familiarity with generative AI concepts would be beneficial.
- OpenAI API Key Access

Let's first install the necessary packages.

```
!pip install llama-index --quiet
!pip install langchain --quiet
!pip install llama-hub --quiet
!pip install singlestoredb --quiet
```
Then, let's set our OpenAI API Key.
```
import os
os.environ["OPENAI_API_KEY"] = "sk-xxx"
```
Next, we'll import the SingleStore vectorstore from Langchain.

```
from langchain.vectorstores import SingleStoreDB
```
After importing SingleStore, we can ingest the docs for LlamaIndex into a new table. This takes three steps:
1. Load raw HTML data using WebBaseLoader
2. Chunk the text.
3. Embed or vectorize the chunked text, then ingest it into SingleStore.

```
from langchain.document_loaders import WebBaseLoader

loader = WebBaseLoader("https://gpt-index.readthedocs.io/en/latest/")
data = loader.load()
```

```
from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size = 500, chunk_overlap = 0)
all_splits = text_splitter.split_documents(data)
```

```
from langchain.embeddings import OpenAIEmbeddings
os.environ["SINGLESTOREDB_URL"] = "admin:password@svc-56441794-b2ba-46ad-bc0b-c3d5810a45f4-dml.aws-oregon-3.svc.singlestore.com:3306/demo"

# vectorstore = SingleStoreDB.from_documents(documents=all_splits, embedding=OpenAIEmbeddings())
vectorstore = SingleStoreDB(embedding=OpenAIEmbeddings())
```

note: you may need to drop the automatically created metadata column to use the SingleStoreReader

Now, we'll use Llama Index to retrieve and query from SingleStore using the SingleStoreReader, a lightweight embedding lookup tool for SingleStore databases ingested with content and vector data.

Note that the full SingleStore vectorstore integration with Llama Index for ingesting and indexing is coming soon!

```
from llama_index import download_loader

SingleStoreReader = download_loader("SingleStoreReader")

reader = SingleStoreReader(
    scheme="mysql",
    host="svc-56441794-b2ba-46ad-bc0b-c3d5810a45f4-dml.aws-oregon-3.svc.singlestore.com",
    port="3306",
    user="admin",
    password="password",
    dbname="demo",
    table_name="embeddings",
    content_field="content",
    vector_field="vector"
)
```

Let's test it out. This function takes a natural language query as input, then does the following:

1. Embed the query using the OpenAI Embedding model, text-embedding-ada-002 by default.

2. Ingest the documents into a Llama Index list index, a data structure that returns all documents into the context.

3. Initialize the index as a Llama Index query engine, which uses the gpt-3.5-turbo OpenAI LLM by default to understand the query and provided context, then generate a response.

4. Returns the response.

```
import json

from llama_index import ListIndex

def ask_llamaindex_docs(query):

  embeddings = OpenAIEmbeddings()
  search_embedding = embeddings.embed_query(query)
  documents = reader.load_data(search_embedding=json.dumps(str(search_embedding)))

  index = ListIndex(documents)

  query_engine = index.as_query_engine()

  response = query_engine.query(query)
  return response
```

```
print(ask_llamaindex_docs("What is Llama Index?"))
```


```
print(ask_llamaindex_docs("What are data indexes in Llama Index?"))
```

```
print(ask_llamaindex_docs("What are query engines in Llama Index?"))
```

![llama output](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0hn05fwze93pbpiipxjd.png)


In essence, the combination of LlamaIndex and SingleStoreDB offers businesses and users a powerful tool to interact with vast amounts of data using natural language, backed by a robust and efficient database system. Proper implementation would enable users to harness the full potential of both technologies, making data-driven decisions faster and more intuitive.

#### Conclusion
In light of the advancements ushered in by LlamaIndex, the horizon for generative AI appears more expansive and transformative than ever before. By seamlessly interfacing vast private datasets with large language models, LlamaIndex promises to elevate the capabilities of generative AI to unprecedented levels, fostering applications that are more informed, contextual and adaptable. 

This combination suggests a future where software solutions are not just data-driven, but also conversationally intelligent — capable of nuanced interactions based on rich, constantly evolving datasets.

Unlock unparalleled performance and efficiency with SingleStore. [Sign up and get $600 worth of free credits](https://www.singlestore.com/cloud-trial/?utm_medium=referral&utm_source=pavan&utm_term=devto&utm_content=llamadevto).