Top 5 rag frames for AI applications

RAG has become a popular technology in 2025, avoids the adjustment of the model that is expensive and that requires a lot of time. There is a greater demand from Marcos de Trapo on the current scenario, we understand what these are. The generation generation frames of the generation (RAG) are essential tools in the field of artificial intelligence. They improve the capacities of large language models (LLM) by allowing them to recover relevant information from external sources. This leads to more precise answers and with the context. Here, we will explore five notable rag frames: Langchain, Llamaindex, Langgraph, Haystack and Ragflow. Each frame offers unique characteristics that can improve their ai projects.

1. Langchain

Langchain It is a flexible frame that simplifies the development of applications using LLM. Provides tools to build rag applications, making integration direct.

• Key features:
  • Modular design for easy customization.
  • Admits several LLM and data sources.
  • Incorporated tools for document recovery and processing.
  • Suitable for chatbots and virtual assistants.

Here is the practice:

Install the following libraries

! pip install langchain_community tiktoken langchain-openai langchainhub chromadb langchain

Configure the OpenAI API key and the environment

from getpass import getpass
openai = getpass("OpenAI API Key:")
import os
os.environ("OPENAI_API_KEY") = openai

Import the following dependencies

import bs4
from langchain import hub
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import Chroma
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

Loading the RAG document using Webbase Loader (replace with your own data)

# Load Documents
loader = WebBaseLoader(
   web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
   bs_kwargs=dict(
       parse_only=bs4.SoupStrainer(
           class_=("post-content", "post-title", "post-header")
       )
   ),
)
docs = loader.load()

Place the document using recursing recurshacrtextsplitter

# Split
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(docs)

Store vector documents in Chromadb

# Embed
vectorstore = Chroma.from_documents(documents=splits,
                                   embedding=OpenAIEmbeddings())
retriever = vectorstore.as_retriever()

Pulling the rag of Hub Langchain and defining Llm

# Prompt
prompt = hub.pull("rlm/rag-prompt")
# LLM
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)

Processing the recovered documents

# Post-processing
def format_docs(docs):
   return "\n\n".join(doc.page_content for doc in docs)

Creating the rag chain

# Chain
rag_chain = (
   {"context": retriever | format_docs, "question": RunnablePassthrough()}
   | prompt
   | llm
   | StrOutputParser()

Invoke the chain with the question

# Question
rag_chain.invoke("What is Task Decomposition?")

Production

‘Task Decomposition is a technique used to break down complex tasks into
smaller and simpler steps. This approach helps agents to plan ahead and
tackle difficult tasks more effectively. Task decomposition can be done
through various methods, including using prompting techniques, task-specific
instructions, or human inputs.’

Also read: Find everything about Langchain here.

2. Llamaindex

<a target="_blank" href="https://www.llamaindex.ai/” target=”_blank” rel=”noreferrer noopener nofollow”>Calledpreviously known as the GPT index, it focuses on organizing and recovering data efficiently for LLM applications. Help developers access and use large data sets quickly.

• Key features:
  • Organize data for fast searches.
  • Customizable components for RAG work flows.
  • Admit multiple data formats, including PDFS and SQL.
  • Integrates with vector stores such as Pineapple and Faiss.

Here is the practice:

Install the following units

!pip install llama-index llama-index-readers-file
!pip install llama-index-embeddings-openai
!pip install llama-index-llms-openai

Import the following dependencies and initialize the LLM and the inlays

from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
llm = OpenAI(model="gpt-4o")
embed_model = OpenAIEmbedding()
from llama_index.core import Settings
Settings.llm = llm
Settings.embed_model = embed_model

Download the data (you can replace them with your data)

!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O './uber_2021.pdf'

Read the data using Simple DirectoryReader

from llama_index.core import SimpleDirectoryReader

documents = SimpleDirectoryReader(input_files=("/content/uber_2021.pdf")).load_data()

Place the document using tokenextsplitter

from llama_index.core.node_parser import TokenTextSplitter
splitter = TokenTextSplitter(
   chunk_size=512,
   chunk_overlap=0,
)
nodes = splitter.get_nodes_from_documents(documents)

Storage of vector integrities in vectorstoreindex

from llama_index.core import VectorStoreIndex
index = VectorStoreIndex(nodes)
query_engine = index.as_query_engine(similarity_top_k=2)
Invoking the LLM using RAG
response = query_engine.query("What is the revenue of Uber in 2021?")
print(response)

Production

‘The revenue of Uber in 2021 was $171.7 million.

3. Langgraph

Langgraph Connect LLM with graphic -based data structures. This framework is useful for applications that require complex data relationships.

• Key features:
  • Efficiently recover data from graphic structures.
  • Combine LLM with graphics data for a better context.
  • It allows the personalization of the recovery process.

Code

Install the following units

%pip install --quiet --upgrade langchain-text-splitters langchain-community langgraph langchain-openai

Initialize the model, inlays and vector database

from langchain.chat_models import init_chat_model
llm = init_chat_model("gpt-4o-mini", model_provider="openai")
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
from langchain_core.vectorstores import InMemoryVectorStore
vector_store = InMemoryVectorStore(embeddings)

Import the following dependencies

import bs4
from langchain import hub
from langchain_community.document_loaders import WebBaseLoader
from langchain_core.documents import Document
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langgraph.graph import START, StateGraph
from typing_extensions import List, TypedDict

Download the data set with webbaseloader (replace it with your own data set)

# Load and chunk contents of the blog
loader = WebBaseLoader(
   web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),
   bs_kwargs=dict(
       parse_only=bs4.SoupStrainer(
           class_=("post-content", "post-title", "post-header")
       )
   ),
)
docs = loader.load()

Document form using recursivehactertextsplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
all_splits = text_splitter.split_documents(docs)
# Index chunks
_ = vector_store.add_documents(documents=all_splits)

# Define prompt for question-answering
prompt = hub.pull("rlm/rag-prompt")
Defining the State, Nodes and edges in Langgraph
Define state for application
class State(TypedDict):
   question: str
   context: List(Document)
   answer: str
# Define application steps
def retrieve(state: State):
   retrieved_docs = vector_store.similarity_search(state("question"))
   return {"context": retrieved_docs}
def generate(state: State):
   docs_content = "\n\n".join(doc.page_content for doc in state("context"))
   messages = prompt.invoke({"question": state("question"), "context": docs_content})
   response = llm.invoke(messages)
   return {"answer": response.content}

Chart compilation

# Compile application and test
graph_builder = StateGraph(State).add_sequence((retrieve, generate))
graph_builder.add_edge(START, "retrieve")
graph = graph_builder.compile()

Invoking the LLM for the rag

response = graph.invoke({"question": "What is Task Decomposition?"})
print(response("answer"))

Production

Task Decomposition is the process of breaking down a complicated task into
smaller, manageable steps. This can be achieved using techniques like Chain
of Thought (CoT) or Tree of Thoughts, which guide models to reason step by
step or evaluate multiple possibilities. The goal is to simplify complex
tasks and enhance understanding of the reasoning process.

4. Haystack

<a target="_blank" href="https://haystack.deepset.ai/” target=”_blank” rel=”noreferrer noopener nofollow”>Haystack It is an end -to -end frame to develop applications fed by LLMS and transformer models. Excellent in the search for documents and the answer to the questions.

• Key features:
  • Combine the search for documents with LLM capabilities.
  • Use several recovery methods for optimal results.
  • It offers pre -constructed pipes for rapid development.
  • Compatible with elasticsearch and Opensearch.

Here is the practice:

Install the following units

!pip install haystack-ai
!pip install "datasets>=2.6.1"
!pip install "sentence-transformers>=3.0.0"
Import the VectorStore and initialise it
from haystack.document_stores.in_memory import InMemoryDocumentStore
document_store = InMemoryDocumentStore()

Loading the data set incorporated from the data library

from datasets import load_dataset
from haystack import Document
dataset = load_dataset("bilgeyucel/seven-wonders", split="train")
docs = (Document(content=doc("content"), meta=doc("meta")) for doc in dataset)

Download the Incrustation Model (you can also replace it with operai inlays)

from haystack.components.embedders import SentenceTransformersDocumentEmbedder
doc_embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
doc_embedder.warm_up()
docs_with_embeddings = doc_embedder.run(docs)
document_store.write_documents(docs_with_embeddings("documents"))

Storage of inlays in vectorstore

from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
retriever = InMemoryEmbeddingRetriever(document_store)

Defining the rag warning

from haystack.components.builders import ChatPromptBuilder
from haystack.dataclasses import ChatMessage
template = (
   ChatMessage.from_user(
       """
Given the following information, answer the question.
Context:
{% for document in documents %}
   {{ document.content }}
{% endfor %}
Question: {{question}}
Answer:
"""
   )
)
prompt_builder = ChatPromptBuilder(template=template)

Initializing the LLM

from haystack.components.generators.chat import OpenAIChatGenerator
chat_generator = OpenAIChatGenerator(model="gpt-4o-mini")

Definition of pipe nodes

from haystack import Pipeline
basic_rag_pipeline = Pipeline()
# Add components to your pipeline
basic_rag_pipeline.add_component("text_embedder", text_embedder)
basic_rag_pipeline.add_component("retriever", retriever)
basic_rag_pipeline.add_component("prompt_builder", prompt_builder)
basic_rag_pipeline.add_component("llm", chat_generator)

Connecting the nodes from each other

# Now, connect the components to each other
basic_rag_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
basic_rag_pipeline.connect("retriever", "prompt_builder")
basic_rag_pipeline.connect("prompt_builder.prompt", "llm.messages")

Invoke the llm using rag

question = "What does Rhodes Statue look like?"
response = basic_rag_pipeline.run({"text_embedder": {"text": question}, "prompt_builder": {"question": question}})
print(response("llm")("replies")(0).text)

Production

Batches: 100%
 1/1 (00:00<00:00, 17.91it/s)
‘The Colossus of Rhodes, a statue of the Greek sun-god Helios, is believed to
have stood approximately 33 meters (108 feet) tall and was constructed with
iron tie bars and brass plates forming its skin, filled with stone blocks.
Although the specific details of its appearance are not definitively known,
contemporary accounts suggest that it had curly hair with bronze or silver
spikes radiating like flames on the head. The statue likely depicted Helios
in a powerful, commanding pose, possibly with one hand shielding his eyes,
similar to other representations of the sun god from the time. Overall, it
was designed to project strength and radiance, celebrating Rhodes' victory
over its enemies.’

5. Ragflow

Rag flow It focuses on integrating recovery and generation processes. Rimina the development of RAG applications.

• Key features:
  • Simplify the connection between recovery and generation.
  • It allows personalized workflows to meet the needs of the project.
  • It is easily integrated with several databases and document formats.

Here is the practice:

Register in the Rag flow And then click Ragflow test

Then click Create Knowledge Base

Then go to the models providers and select the LLM model you want to use, we are using Groq here and paste your API key.

Then go to the system model configuration and select the chat model from there.

Now go to data sets and load the PDF you want, then click on the Play button near the analysis column and wait for the PDF to be analyzed.

Now go to the chat section, create an assistant there, give it a name and also select the knowledge base you created.

Then create a new chat and ask the question that will ask a rag on your knowledge base and answer accordingly.

Conclusion

RAG has become an important technology for custom business data sets in recent times, hence RAG Marcos has increased dramatically. Mark like Langchain, Llamaindex, Langgraph, Haystack and Ragflow represent significant advances in ai applications. When using these frames, developers can create systems that provide precise and relevant information. As ai continues to evolve, these tools will play an important role in the configuration of intelligent applications.