Best RAG Frameworks in 2026

By Rajesh Kannan, Co-Founder & CTO, Gramosoft · Last updated: November 5, 2026 · Lab results from our own loader test on November 5, 2026 (LangChain 1.4, LlamaIndex 0.14, Haystack 3.4, DSPy 3.4)

The best RAG frameworks in 2026 are GsearchAI as a ready-made enterprise platform that combines graph RAG and vector RAG, LangChain with LangGraph, LlamaIndex, Haystack and DSPy as libraries, RAGFlow as a self-hosted engine, and LightRAG for graph retrieval. They differ in licence, footprint, evaluation and how much they decide for you. This guide compares them, shows what our loader lab found, and explains where GcrawlAI fits when your knowledge base comes from the web.

The best RAG frameworks at a glance

Clean web pages for any RAG framework: GcrawlAI

Every framework in this guide expects text going in. When that text comes from websites, the loader decides what your index holds, and most built-in web loaders don't run JavaScript. GcrawlAI renders each page in a real browser and returns clean Markdown, so LangChain, LlamaIndex, Haystack or DSPy start from the page a reader sees.

The homepage says it plainly: JavaScript rendering, anti-bot stealth and proxies come with every request, with no credit system. For a RAG pipeline that means one call per page and Markdown you can split, instead of a browser fleet you keep alive next to your vector store.

This is the ingestion step on its own. It renders each URL to Markdown, skips pages that come back without real text, and keeps the source URL and fetch time so answers can cite them. The Document class is LangChain's; LlamaIndex and Haystack take the same text and metadata.

# pip install gcrawl-sdk langchain-core   (swap the Document class for LlamaIndex or Haystack: same text + metadata)
"""Render pages to Markdown with GcrawlAI, keep the source URL and fetch time, and hand clean
Documents to whichever RAG framework you use. Pages that come back without text are skipped."""
import os
from datetime import datetime, timezone

from gcrawl_sdk import GcrawlClient, ScrapeOptions
from langchain_core.documents import Document

gc = GcrawlClient(api_key=os.getenv("GCRAWL_API_KEY", "gc-YOUR_API_KEY"))
urls = ["https://docs.astral.sh/uv/concepts/tools/", "https://docsify.js.org/#/quickstart"]

docs = []
for url in urls:
    page = gc.scrape(url=url, options=ScrapeOptions(markdown_enabled=True, proxy_geo="US"), wait=True)
    text = (page.markdown or "").strip()
    if len(text) < 200:                       # an empty shell or a block page is not a document
        print(f"skipped {url}: {len(text)} characters")
        continue
    docs.append(Document(page_content=text, metadata={
        "source": url, "fetched_at": datetime.now(timezone.utc).isoformat(timespec="seconds")}))

print(f"{len(docs)} documents ready for your splitter and index")

• Rendering and access: a real browser through residential IPs in the country you choose, with retries and stealth escalation inside the request.
• Output for retrieval: Markdown, HTML or JSON, plus extractors that return structured fields for common page types.
• Scrape, crawl and Search API: scrape single pages, crawl a whole docs site, or use the Search API to find fresh sources for corrective RAG.
• For developers and AI agents: a Python SDK, an MCP server for Claude, Cursor and other agents, the Playground to test a page first, and the docs.

The MIT-licensed core also runs on your own servers: clone it from GitHub and the setup script in the code download starts the API with Redis and a Celery worker.

Pricing is a free plan of 50 requests a month with no card, paid plans from $0.67 to $1.45 per 1,000 requests, and a self-hosted core that costs nothing. Failed requests are never charged. The full plan table is in the cost section.

Where it falls short: GcrawlAI isn't a RAG framework. It doesn't chunk, embed, retrieve or generate; you still pick one of the frameworks below. No service reaches every page, so test your sources on the free plan, and it doesn't make collecting a site's content acceptable when the site's terms say no.

"Most RAG bugs we debug aren't retrieval bugs. The answer was never in the index, because the loader saved a menu and a cookie banner instead of the page."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

What a RAG framework actually does

A RAG framework is the code that connects your documents to a language model: it loads sources, splits them into chunks, stores them in an index, retrieves the relevant chunks for a question and builds the prompt. It isn't the vector database, the model or the evaluation tool, though most frameworks plug into all three.

The phrase covers three different things, as VDF AI points out, and mixing them up wastes evaluation time:

• Libraries such as LangChain, LlamaIndex, Haystack, DSPy and txtai. You import components and own the service, API and operations.
• Engines such as RAGFlow, Kotaemon and the LightRAG server. They ship a running system with a UI and an API; you configure more than you code.
• Platforms such as GsearchAI that add connectors, identity, permissions and audit across many use cases. You deploy them rather than assemble them.

RAG itself also varies. Turing Post contrasts traditional RAG, which retrieves once and then generates, with agentic RAG, where a model plans, retrieves several times and decides when it has enough evidence. Agentic RAG needs a framework with state and loops; a FAQ assistant usually doesn't.

RAG frameworks compared: licence, status and footprint

Licence and maintenance narrow the field before features do. The core libraries are MIT or Apache 2.0, but some add-ons and hosted platforms aren't, and several frameworks from older comparison lists are archived or stalled. Install size also varies about fourfold, which matters for containers, cold starts and security review.

Sizes are fresh virtual environments on Python with only the core package installed, measured November 5, 2026; import time is the median of five cold imports. Adding loaders changes the picture: LlamaIndex's web readers pulled in Playwright, Selenium and newspaper3k and took the environment to 123 packages and 570 MB.

Check the licence of every add-on, not only the core. llama-index-readers-web is published under GPL-3.0-or-later in its package metadata, while LlamaIndex core is MIT. OvalEdge also notes that LangGraph and LangChain core are MIT, but the hosted LangGraph Platform runs under a separate commercial licence.

The best RAG frameworks, one by one

Each framework below has a clear best case and a known weak spot. Versions and statuses come from the projects and from VDF AI's October 2026 check; footprints and loader behaviour come from our own lab. Pick by the job you're doing, not by GitHub stars.

GsearchAI

GsearchAI is an enterprise RAG search and chat platform that takes a hybrid approach, graph RAG plus vector RAG, built by Gramosoft, the team behind GcrawlAI. Instead of assembling loaders, splitters and retrievers, you connect your workplace tools and ask questions in plain language. Its site lists connectors for more than 100 apps across document stores, chat, ticketing, CRM and wikis.

• Answers with sources: one answer per question with a citation, fetched from connected tools in real time rather than copied into a separate store.
• Permissions carry over: people only see answers from content they can already open, with admin controls, audit logs and sensitive-data detection.
• Graph RAG and vector RAG together: a knowledge graph (Neo4j) maps how people, projects, products and documents connect, while vector search (pgvector) finds the passages that match a question by meaning. Each query draws on both, so it handles lookups and multi-hop "how is X related to Y" questions, the gap that graph-only tools such as LightRAG and GraphRAG were built for.
• Your model, your cloud: bring the model provider and keys you choose, and run it in Gramosoft's cloud or your own. It also works in Slack.

Individuals can start free with no card; company rollouts go through a demo. The source is on GitHub. Where it fits less well: if you need full control of every pipeline step or want to embed RAG inside your own product's code, a library such as LangChain, LlamaIndex or Haystack is the better base. We build it, so test it against your own questions as you would any other option.

LangChain and LangGraph

LangChain is the integration hub, and LangGraph is the runtime its agents run on, with durable execution, human-in-the-loop interrupts and memory. Both reached 1.0 on October 17, 2025. LangChain's docs describe 2-step, agentic and hybrid RAG. Its WebBaseLoader, RecursiveUrlLoader and SitemapLoader fetch raw HTML; browser loaders need Playwright or Selenium installed. In our lab its BM25 retriever missed "schedules" against "scheduling", because the default doesn't stem words.

LlamaIndex

LlamaIndex builds outward from the index: readers, parsers, node splitters and query engines, with more than 300 integration packages and the most complete evaluation module of the libraries here. VDF AI notes the company's focus has shifted to LlamaParse, its commercial parser. Its SimpleWebPageReader doesn't run JavaScript, and in our lab it decoded "©" as "©" when the server sent no charset.

Haystack

Haystack, from deepset, builds RAG as explicit pipelines of typed components, so every step can be inspected and tested. Version 3.0 (July 20, 2026) added agent hooks. It ships statistical evaluators (exact match, MRR, MAP, NDCG, recall) and model-based ones (faithfulness, context relevance), and Hayhooks serves a pipeline as REST or MCP. In our lab, HTMLToDocument raised an ImportError until we installed trafilatura separately.

DSPy

DSPy, from Stanford NLP, treats a RAG system as a program whose prompts are compiled against a metric. Its own tutorial reports MIPROv2 lifting semantic F1 from about 42% to 61% on its dev set, which is the project's example, not a general benchmark. DSPy has no loaders or splitters: dspy.retrievers offers Embeddings, EmbeddingsWithScores and Retrieve, so you bring the documents.

RAGFlow

RAGFlow is a self-hosted engine with a web UI, not a library. Its DeepDoc module handles layout analysis, OCR and tables, and chunks can be corrected by hand. The 1.0.0-rc1 release moves the server to Go. ScrapingBee notes it ships breaking changes often and that its README doesn't say it runs JavaScript, so upload rendered Markdown for client-rendered sites.

LightRAG and Microsoft GraphRAG

LightRAG adds a knowledge graph to vector retrieval and updates incrementally, at far lower indexing cost than full GraphRAG. Microsoft GraphRAG answers corpus-wide questions from community summaries, but its README says it's largely in maintenance mode and that indexing can be expensive. Reach for either only when relationships across documents matter more than finding one passage.

txtai, Cognee, Mastra and Microsoft Agent Framework

• txtai (Apache 2.0): one package with an embeddings database, RAG pipeline, agents and an MCP API. Good for small teams that want one dependency.
• Cognee (Apache 2.0 core): turns documents into graph memory that agents recall across sessions. Its core has no web loader.
• Mastra and the Vercel AI SDK: the TypeScript route for RAG and agents. Mastra is Apache 2.0 except its ee/ code.
• Microsoft Agent Framework (MIT): for .NET and Azure teams building agents with retrieval.

Skip for new projects: Weaviate's Verba and TrueFoundry's Cognita are archived on GitHub, and R2R hasn't had a release since June 2025, according to VDF AI. Longer lists, such as Firecrawl's 15 open-source picks, also mix in vector databases and memory layers like Milvus and mem0, which sit beside a framework rather than replace it.

Loading web data: the step that decides answers

Framework comparisons spend pages on retrievers and agents, but a RAG system can only answer from what its loader saved. Most built-in web loaders fetch HTML over plain HTTP and strip the tags. That works for server-rendered pages and fails quietly on pages that build their content in the browser.

ScrapingBee measured this across four docs sites. LangChain, LlamaIndex, Haystack, DSPy and plain Python tied on answer correctness (0.631 to 0.641), while indexing rendered Markdown instead of default-loader text lifted correctness from 0.50 to 0.64, and from 0.22 to 0.61 on JavaScript-only pages, according to ScrapingBee's benchmark. Its LlamaIndex, Haystack and LightRAG adapters also broke on the Anthropic SDK 1.x, so pin versions and test after upgrades.

Before you index a site, load one page with your framework's default loader and look at it:

# pip install langchain-community beautifulsoup4
"""Before indexing a site, load one page with your framework's default web loader and look at what came back."""
from langchain_community.document_loaders import WebBaseLoader

url = "https://docsify.js.org/#/quickstart"          # a page that builds its content in the browser
text = WebBaseLoader(url).load()[0].page_content.strip()
print(f"{len(text)} characters: {text[:80]!r}")
# A tiny result, or the same text on every page, means the loader got the empty app shell:
# render the pages first (a headless browser or a rendering API) and index that instead.

On our client-rendered test page this printed 274 characters: the page title, the docs menu and nothing else. If every page returns the same short text, render the pages first. The guide to scraping dynamic JavaScript websites with Python covers how to tell the two kinds of page apart.

What our loader lab found

We built a 12-page docs site, six pages server-rendered and six that build their text in JavaScript, and wrote one question per page. Each framework loaded the site with its own web loader, split it, and retrieved the top three chunks with BM25. Then we repeated it with browser-rendered Markdown. No language model was involved, so results are reproducible.

Three things stood out. First, the frameworks behaved identically where it mattered: every default loader saved only the title, menu and footer of the JavaScript pages, so none could answer those six questions. Second, rendering fixed all of it. Third, the one remaining miss was LangChain's BM25 default, which doesn't stem words, so "schedules" didn't match "scheduling". A stemmer or an embedding retriever would fix that.

The lab is deliberately small: 12 pages, one fictional product, keyword retrieval and no generation step. It tests what reaches the index, not answer quality or latency. DSPy isn't in the table because it has no web loader to test. The scripts and results are in the code download.

"We expected the frameworks to disagree. They agreed perfectly: all three lost the same six pages. Swapping the framework wouldn't have fixed a single answer, while rendering the pages fixed all of them."

Rajesh Kannan, Co-Founder & CTO at Gramosoft

How to evaluate a RAG framework before you commit

Choose with your own questions, not someone else's benchmark. Build a small labelled set of real user questions and the passages that answer them, then score retrieval and generation separately. A framework whose evaluators your team will actually run in CI beats a more capable one nobody tests.

• Retrieval: hit rate, recall, MRR and NDCG. Haystack and LlamaIndex include these.
• Generation: faithfulness to the retrieved context and answer relevance, from Haystack, LlamaIndex, LangChain's openevals, or wrappers for Ragas and DeepEval.
• End to end: semantic overlap with reference answers, such as DSPy's SemanticF1.

Evaluation tools sit beside the framework. Maxim's roundup covers LangSmith for LangChain tracing, Arize Phoenix for open-source observability, Ragas for reference-free metrics and DeepEval for pytest-style tests. Run your set after every change to chunking, embeddings, prompts or the model.

What this guide doesn't cover

This is a comparison of open-source frameworks, not a full RAG architecture guide. Vector databases, embedding models, rerankers and managed cloud RAG services are separate decisions with their own trade-offs. Our lab measured loaders and keyword retrieval only, so it says nothing about answer quality, latency or token cost.

It also doesn't cover collecting content you aren't allowed to collect. If a site blocks automated access, shows a CAPTCHA or puts content behind a login, ask the owner for access or a data export instead of working around it.

What clean web pages for RAG cost

The frameworks are free, but getting web pages into them isn't: rendering, proxies and servers cost money whether you run them or rent them. For 100,000 successful protected pages a month, credit-based APIs cost $249 to $399 at list price and GcrawlAI costs $101.

List-price arithmetic, not a benchmark. Credit costs and billing rules come from ScraperAPI's credit docs, ZenRows' pricing docs and ScrapingBee's FAQ, checked November 1, 2026. The honest read: for plain HTML pages, ZenRows, ScraperAPI and ScrapingBee cost less than GcrawlAI, and a framework's free default loader costs nothing when your sources are server-rendered. A docs site you re-crawl weekly is a few thousand pages a month, which fits the smaller plans.

GcrawlAI plans (GcrawlAI pricing, checked October 28, 2026):

Every plan, Free included, has scrape, crawl, the Search API, JavaScript rendering, residential IP rotation and stealth escalation in each request, and each feature counts as one request. Failed requests are never charged. Annual billing charges 10 months for 12, unused requests on paid plans roll over once, and Indian customers are billed in INR with a GST invoice.

Which RAG framework fits your project

Pick by the job, then by your team. Company-wide search without code points to GsearchAI, agents and integrations to LangChain, documents to LlamaIndex, testable pipelines to Haystack, and metric-driven tuning to DSPy. Web pages going in should be rendered and clean. The table shows where GcrawlAI fits in each case.

When plain Python is enough

You may not need a framework at all. ScrapingBee's 47-line plain Python pipeline matched every framework on answer correctness with the smallest install. A splitter, an embedding model, a vector store client and one prompt cover many internal assistants. Frameworks pay off when you need agents, evaluators or many integrations.

Either way, keep ingestion separate from retrieval. Send the pages to GcrawlAI, store the Markdown with its source URL, and index from that store, so you can switch frameworks without re-collecting anything. The free Cloud plan's 50 requests a month are enough to test your real sources, the Playground shows the Markdown without code, and the MIT core self-hosts for free.

Building RAG on web content responsibly

A knowledge base built from websites inherits their rules. Read each site's terms and robots.txt, prefer official APIs, data licences or the site's own llms.txt, stay on public pages, crawl slowly, and don't index personal data you have no basis to hold. When a site shows a CAPTCHA, stop and ask for access.

Keep the source URL and fetch date on every chunk so answers can cite where they came from, and re-crawl on a schedule so stale pages don't outlive their corrections. For the rules sites publish, read how to check if a website allows scraping.

Related guides

• Web Scraping for RAG: The Complete Engineering Guide to Clean LLM Data Ingestion in 2026
• Web Scraping With LlamaIndex: Load Any Website Into Your Index
• Website Data for LLM: How to Extract Clean, Token-Efficient Web Data for AI & RAG (2026 Guide)
• Corrective RAG (CRAG) with Live Web Search: How to Stop AI Hallucinations in 2026
• Building an Autonomous Deep Research Agent with GcrawlAI & LangChain
• How to Create an llms.txt File for Any Website
• Model Context Protocol (MCP) Web Scraping: How to Connect AI Agents to the Live Web
• How to Scrape Dynamic JavaScript Websites with Python (2026 Guide)