Learn to build large language model applications: vector databases, langchain, fine tuning and prompt engineering. Learn more

LlamaIndex is an orchestration framework for large language model (LLM) applications. LLMs like GPT-4 are pre-trained on massive public datasets, allowing for incredible natural language processing capabilities out of the box. However, their utility is limited without access to your own private or domain-specific data. 

LlamaIndex solves this problem by providing a way to ingest, structure, and access your own data for use with LLMs. It supports a variety of data sources, including APIs, databases, and PDFs.

Learn to build LLM applications                                          


Once your data is indexed, it provides a number of ways to interact with it, including: 

  • Natural language querying: You can ask LlamaIndex questions about your data in plain English. For example, you could ask “What are the top 10 revenue-generating products?” or “What are the most common customer complaints?” 
  • Conversation with LLM-powered data agents: It can be used to create chatbots or other conversational interfaces that can access and process your data in real-time. This allows you to build applications that can provide personalized assistance to your users or answer their questions in a comprehensive and informative way. 
  • LLM-powered data analytics: It can also be used to power LLM-based data analytics applications. For example, you could use it to build a system that can automatically generate reports or insights from your data. 


Tune in to our Future of Data and AI Podcast featuring Co-founder and CEO of LlamaIndex, Jerry Liu himself!

Key components of LlamaIndex: 

The key components of LlamaIndex are as follows:  

  • Data connectors: These components allow LlamaIndex to ingest data from a variety of sources, such as APIs, databases, and PDFs. The data is converted into a simple document format that is easy for LlamaIndex to process. 
  • Data index: A data structure that stores the data in a way that makes it easy for LlamaIndex to find the relevant information when a user asks a question or starts a conversation. 
  • Retrievers: Retrievers are responsible for finding the most relevant information in the data index based on the user’s query or chat message. 
  • Query engines: Allow users to ask questions about their data in natural language. They accept natural language queries and provide comprehensive and informative responses. 
  • Chat engines: Allow users to have interactive conversations with their data. They maintain a contextual understanding of the conversation history and can provide answers that consider the relevant past context. 




In this tutorial, we will delve into the technical intricacies of constructing intelligent chatbots that leverage advanced technologies. Our example code will illustrate the development of a PDF Q&A chatbot that incorporates the OpenAI language model, VectorStoreIndex for document indexing and Streamlit for user interface design.

Large language model bootcamp


Furthermore, the chatbot will be equipped with the Llama Index’s Conversational Retrieval Chain, enabling it to furnish precise responses based on user queries. Let’s embark on this journey into the technical aspects of crafting a highly capable chatbot. 

Importing necessary libraries  

To commence our chatbot project, we need to import crucial libraries and functions. Here’s a breakdown of the libraries we will be utilizing: 

  • LlamaIndex: We harness the power of the Llama Index, a comprehensive framework tailored for developing applications enriched by language models. 
  • Streamlit: Streamlit, a Python library, serves as our toolkit for swiftly constructing web applications with an intuitive interface that facilitates user interaction. 


Setting OpenAI API key  

To access OpenAI’s language models effectively, it is imperative to configure our API key. Replace the placeholder with your actual OpenAI API key, obtainable from the OpenAI API platform. This key will act as our gateway to the powerful language models offered by OpenAI. Also you can use the dotenv route where you place your OPENAI key in the .env file. 


Setting up the user interface: 

This section delves into the creation of our user interface using Streamlit. The interface is meticulously designed to be clean, user-friendly, and feature-rich. It encompasses a title and a minimalist sidebar, providing an entry point for users to engage with our Q&A chatbot seamlessly.

user interface



Follow Data Science Dojo on Medium to stay updated with LLM and Generative AI 


Main function and data loading: 

At the core of our chatbot lies the main function, which orchestrates the entire application logic. We initiate the process by loading data from a specified directory using a SimpleDirectoryReader. This data will serve as the knowledge repository from which our chatbot will draw answers to user inquiries. 

Data loading


Creating a service context: 

To enable the advanced natural language processing capabilities of our chatbot, we established a ServiceContext. This context is pre-configured with default settings and an OpenAI language model (llm). It lays the groundwork for our chatbot’s ability to understand and generate responses to user queries effectively. 

service context





Building the LlamaIndex: 

The pivotal component of our chatbot’s capabilities is the Llama Index. We construct this index using VectorStoreIndex, a versatile tool that optimizes the stored documents for efficient searching. This step ensures that our chatbot can rapidly retrieve pertinent information when faced with user queries. 

vector store index


User input and chat engine: 

Our user interface empowers users to input questions related to the provided data through a text input field. The chat engine processes these queries by harnessing the capabilities of the Llama Index. Subsequently, it generates responses based on the content indexed from the documents. This interaction constitutes the core functionality of our Q&A chatbot. 


User input


Running the application: 

With all the components in place, we culminate our code by executing the main function. This pivotal step transforms our project into an interactive chatbot. Users can seamlessly pose questions, and the chatbot, equipped with the Llama Index, responds with precise answers drawn from the indexed documents. 

Running the application



Benefits of using LlamaIndex 

There are a number of benefits to using LlamaIndex to create custom LLM applications: 

  • It is easy to use: Provides a simple and intuitive API for interacting with your data. 
  • It is flexible: Supports a variety of data sources and formats. It also provides a number of plugins and integrations that can be used to extend its functionality. 
  • It is scalable: Scaled to handle large datasets and high traffic volumes. 

In conclusion, this guide has offered a comprehensive roadmap for creating personalized Q&A chatbots with the Llama Index at their core.

By integrating cutting-edge technologies such as OpenAI for language processing, VectorStoreIndex for efficient document indexing, and the Llama Index’s Conversational Retrieval Chain, we have unlocked the potential for engaging, informative, and highly interactive question-answering experiences.

Feel encouraged to explore and expand upon this chatbot project, extending its capabilities to tackle more intricate tasks and challenges within the realm of AI-driven conversational systems. 

September 28, 2023

MAANG has become an unignorable buzzword in the tech world. The acronym is derived from “FANG”, representing major tech giants. Initially introduced in 2013, it included Facebook, Amazon, Netflix, and Google. Apple joined in 2017. After Facebook rebranded to Meta in June 2022, the term changed to “MAANG,” encompassing Meta, Amazon, Apple, Netflix, and Google.


Moreover, efficient collaboration and version control are vital for streamlined software development. Enter Git, the ubiquitously distributed version control system that has become the gold standard for managing code repositories. Discover how Git’s best practices enhance productivity, collaboration, and code quality in big organizations.

Top 10 Git practices followed in MAANG

1. Creating a clear and informative repository structure 

To ensure seamless navigation and organization of code repositories, we should follow a well-defined structure for their GitHub repositories. Clear naming conventions, logical folder hierarchies, and README files with essential information are implemented consistently across all projects. This structured approach simplifies code sharing, enhances discoverability, and fosters collaboration among team members. Here’s an example of a well-structured repository:  

Creating a repository structure
Creating a repository structure

By following such a structure, developers can easily locate files and understand the overall project organization.  

2. Utilizing branching strategies for effective collaboration  

The effective utilization of branching strategies has proven instrumental in facilitating collaboration between developers. By following branching models like GitFlow or GitHub Flow, team members can work on separate features or bug fixes without disrupting the main codebase. This enables parallel development, seamless integration, and effortless code reviews, resulting in improved productivity and reduced conflicts. Here’s an example of how branching is implemented: 

Utilizing branching strategies
Utilizing branching strategies

3. Implementing regular code reviews  

MAANG developers place significant emphasis on code quality through regular code reviews. GitHub’s pull request feature is extensively utilized to ensure that each code change undergoes thorough scrutiny. By involving multiple developers in the review process. Code reviews enhance the codebase’s quality and provide valuable learning opportunities for team members. 

Here’s an example of a code review process: 

  1. Developer A creates a pull request (PR) for their code changes. 
  2. Developer B and Developer C review the code, provide feedback, and suggest improvements. 
  3. Developer A addresses the feedback, makes necessary changes, and pushes new commits. 
  4. Once the code meets the quality standards, the PR is approved and merged into the main codebase. 

By following a systematic code review process, MAANG ensures that the codebase maintains a high level of quality and readability.

4. Automated testing and continuous integration 

Automation plays a vital role in MAANG’S GitHub practices, particularly when it comes to testing and continuous integration (CI). MAANG leverages GitHub Actions or other CI tools to automatically build, test, and deploy code changes. This practice ensures that every commit is subjected to a battery of tests, reducing the likelihood of introducing bugs or regressions into the codebase. 

Automated testing and continuous integration
Automated testing and continuous integration

5. Don’t just git commit directly to master 

 Avoid committing directly to the master branch in Git, regardless of whether you follow Gitflow or any other branching model. It is highly recommended to enable branch protection to prevent direct commits and ensure that the code in your main branch is always deployable. Instead of committing directly, it is best practice to manage all commits through pull requests.  

Manage all commits through pull requests
Manage all commits through pull requests

6. Stashing uncommitted changes 

If you’re ever working on a feature and need to do an emergency fix on the project, you could run into a problem. You don’t want to commit to an unfinished feature, and you also don’t want to lose current changes. The solution is to temporarily remove these changes with the Git stash command: 

Stashing uncommitted changes
Stashing uncommitted changes

7. Keep your commits organized 

You just wanted to fix that one feature, but in the meantime got into the flow, took care of a tricky bug, and spotted a very annoying typo. One thing led to another, and suddenly you realized that you’ve been coding for hours without actually committing anything. Now your changes are too vast to squeeze in one commit… 

Keep your commits organized
Keep your commits organized

8. Take me back to good times (when everything works flawlessly!)  

It appears that you’ve encountered a situation where unintended changes were made, resulting in everything being broken. Is there a method to undo these commits and revert to a previous state?  With this handy command, you can get a record of all the commits done in Git. 

Git Command
Git Command

All you must do now is locate the commit before the troublesome one. The notation HEAD@{index} represents the desired commit, so simply replace “index” with the appropriate number and execute the command. 

And there you have it you can revert to a point in your repository where everything was functioning perfectly. Keep in mind to only use this feature locally, as making changes to a shared repository is considered a significant violation.  

9. Let’s confront and address those merge conflicts commits

You are currently facing a complex merge conflict, and despite comparing two conflicting versions, you’re uncertain about determining the correct one. 

Resolving merge conflicts
Resolving merge conflicts

Resolving merge conflicts may not be an enjoyable task, but this command can simplify the process and make your life a bit easier. Often, additional context is needed to determine which branch is the correct one. By default, Git displays marker versions that contain conflicting versions of the two files. However, by choosing the option mentioned, you can also view the base version, which can potentially help you avoid some difficulties. Additionally, you have the option to set it as the default behavior using the provided command.

10. Cherry-Picking commits

Cherry-picking is a Git command, known as git cherry-pick, that enables you to selectively apply individual commits from one branch to another. This approach is useful when you only need certain changes from a specific commit without merging the entire branch. By using cherry-picking, you gain greater flexibility and control over your commit history. 

Cherry-Picking commits
Cherry-Picking commits

In a nutshell

The top 10 Git practices mentioned above are indisputably essential for optimizing development processes, fostering efficient collaboration, and guaranteeing code quality. By adhering to these practices, MAANG’s Git framework provides a clear roadmap to excellence in the realm of technology. 

Prioritizing continuous integration and deployment enables teams to seamlessly integrate changes and promptly deploy new features, resulting in accelerated development cycles and enhanced productivity. Embracing Git’s branching model empowers developers to work on independent features or bug fixes without affecting the main codebase, enabling parallel development and minimizing conflicts. Overall, these Git practices serve as a solid foundation for efficient and effective software development 


May 17, 2023