Multi-Source RAG: A Plain-Language Guide

Project Reference : https://www.youtube.com/watch?v=swCPic00c30&t=1366s

1. Why this matters

• LLMs forget facts fast. A model like GPT-4 doesn’t ship with fresh Wikipedia edits, niche research papers, or your private docs.
• RAG fixes that by letting the model “look things up” moments before it answers.
• Multi-source RAG goes further: the model may pull from several knowledge wells—Wikipedia for quick overviews, arXiv for research abstracts, your own docs for product specifics then weave everything into one coherent reply.

2. Key ideas in everyday words

• Large Language Model (LLM) – A text-prediction engine (e.g., GPT-3.5) that you chat with.
• Retriever – A search helper that finds the most relevant passages in a corpus, using embeddings (mathematical fingerprints of text).
• Vector store – A searchable “library” where each passage is saved as a vector; FAISS is a popular open-source option.
• Tool – A wrapper that tells the LLM, “If you need X, call this function with Y arguments.”
• Agent – A brain that decides when to call tools versus when to just answer.
• Graph / Nodes / Edges / State – Picture a flowchart: each node does one job (search, filter, answer), edges define the order, and state is the memory that flows through (the question, retrieved text, partial thoughts). LangGraph lets you draw this explicitly; LangChain’s AgentExecutor builds a simple one for you.

3. Big-picture roadmap

1. Pick your sources (Wikipedia, arXiv, your website).
2. Create retrievers for each source.
3. Wrap each retriever as a tool with a friendly description.
4. Spin up an LLM (ChatOpenAI, temperature = 0 for factual answers).
5. Assemble an agent that can call those tools.
6. (Optionally) Draw it as a graph if you want fine-grained control.
7. Expose it via Gradio so non-coders can use it from a browser.

4. Sequence of operations at runtime

1. User types a question.
2. Agent reads system prompt → decides: “I need external facts.”
3. Agent chooses the right tool (Wikipedia / arXiv / LangSmith search).
4. Tool runs → returns a short snippet.
5. Snippet + original question feed back into LLM.
6. LLM crafts the final answer, cites evidence, returns to user.

5. Ingredients you need

• Python ≥ 3.10
• Libraries: langchain, langchain-openai, langchain-community, faiss-cpu, python-dotenv, gradio.
• OpenAI API key in a .env file (OPENAI_API_KEY=”sk-…”).
• Optional keys for other APIs if required (not needed for Wikipedia or arXiv).

6. Building a minimal multi-source RAG (copy-paste friendly)

# ---- 1. Install once (shell) ----
# pip install langchain langchain-openai langchain-community faiss-cpu gradio python-dotenv

# ---- 2. Set env variable in a .env file ----
# OPENAI_API_KEY=sk-...

# ---- 3. Python script ----
from dotenv import load_dotenv; load_dotenv()
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.utilities import WikipediaAPIWrapper, ArxivAPIWrapper
from langchain_community.tools import WikipediaQueryRun, ArxivQueryRun
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain.tools.retriever import create_retriever_tool
from langchain.agents import create_openai_tools_agent, AgentExecutor
import gradio as gr

# (A)  LLM
llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)

# (B)  Wikipedia tool
wiki = WikipediaQueryRun(
    api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=200)
)

# (C)  arXiv tool
arxiv = ArxivQueryRun(
    api_wrapper = ArxivAPIWrapper(top_k_results=1, doc_content_chars_max=200)
)

# (D)  LangSmith docs → vector store → retriever tool
loader   = WebBaseLoader("https://docs.smith.langchain.com/")
docs     = loader.load()
chunks   = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200).split_documents(docs)
vectordb = FAISS.from_documents(chunks, OpenAIEmbeddings())
langsmith_tool = create_retriever_tool(
    vectordb.as_retriever(),
    "langsmith_search",
    "Search LangSmith documentation"
)

tools = [wiki, arxiv, langsmith_tool]

# (E)  Agent
from langchain import hub
prompt = hub.pull("hwchase17/openai-functions-agent")
agent  = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=False)

# (F)  Gradio UI
def answer(q):
    return executor.invoke({"input": q})["output"]

demo = gr.Interface(
    fn=answer,
    inputs=gr.Textbox(lines=1, label="Ask me anything"),
    outputs=gr.Textbox(label="Answer"),
    title="Multi-Source RAG Demo"
)

if __name__ == "__main__":
    demo.launch() 

What this code gives you

• A single-page web app.
• Users type a question; behind the scenes the agent may hit up to three sources.
• The model’s reasoning remains hidden, but you can flip verbose=True to watch step-by-step calls in your console.

7. Typical use cases

• Tech-support bots that combine public docs + internal run-books.
• Academic aides that blend Wikipedia intros with peer-reviewed paper abstracts.
• Enterprise search where each department’s knowledge base is its own retriever tool.
• Learning assistants that link textbook snippets with latest research updates.

8. Common “got-its” beginners ask

• “Can I add PDFs?” — Yes, use PyPDFLoader. Everything else stays the same.
• “Will this blow my token budget?” — Limit doc_content_chars_max and set temperature=0 to keep responses short.
• “Do I need GPT-4?” — For straightforward Q-A, gpt-3.5-turbo is fine; upgrade when answers feel flimsy.
• “What if two tools return conflicting info?” — Add a final “verifier” node that checks consistency or cites both with a disclaimer.
• “How do I cite sources?” — Include URL text in each snippet and ask the LLM to preserve them in the final answer.

9. Where to take it next

• Persist your FAISS index so you don’t recompute embeddings.
• Stream tokens in Gradio for a snappier UX (gr.ChatInterface makes this easy).
• Move to LangGraph if you want explicit nodes like Retriever → ReRanker → Answerer.
• Add guards (filters, profanity checks) before sending user input to the LLM.
• Monitor with LangSmith tracing to see which tool each question triggers most.

10. Closing example prompt & reply

User: “What is LangSmith, and does arXiv paper 1605.08386 relate to it?” Agent (behind the scenes):

11. RESULTS