Comment implémenter Agentic RAG avancé en 2026

pip install langchain langchain-openai langchain-community langchain-experimental chromadb pypdf tiktoken

mkdir agentic_rag_project
cd agentic_rag_project

# Créer un fichier .env pour les clés
cat > .env << EOF
OPENAI_API_KEY=sk-your-key-here
EOF

import os
from dotenv import load_dotenv
import chromadb
from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.docstore.document import Document

load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

# Simuler un PDF ; remplacez par vos docs réels
fake_docs = [
    Document(page_content="L'Agentic RAG utilise des agents pour router dynamiquement les queries vers retrieval ou tools.", metadata={"source": "rag101.pdf"}),
    Document(page_content="Exemple : query financière -> retrieve docs SEC + calcule ratios.", metadata={"source": "finance.pdf"}),
    Document(page_content="Multi-hop : question 1 retrieve, question 2 raffine avec tool web.", metadata={"source": "advanced.pdf"})
]

# Splitter les docs (chunk_size=1000 pour équilibre précision/vitesse)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splits = text_splitter.split_documents(fake_docs)

# Embeddings et vector store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(
    documents=splits,
    embedding=embeddings,
    persist_directory="./chroma_db"
)
vectorstore.persist()
print("Vector store créé et persisté.")

from langchain.tools.retriever import create_retriever_tool
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain_community.utilities import DuckDuckGoSearchAPIWrapper

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# Retriever tool depuis vectorstore persistant
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=OpenAIEmbeddings())
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
rag_tool = create_retriever_tool(
    retriever,
    "rag_search",
    "Recherche sémantique dans la base de connaissances Agentic RAG. Utile pour facts précis sur RAG et agents."
)

@tool
def calculator(expression: str) -> str:
    """Évalue des expressions mathématiques."""
    try:
        return str(eval(expression))
    except:
        return "Erreur de calcul."

# Web search simulé
search = DuckDuckGoSearchAPIWrapper()

print("Outils créés : rag_search, calculator, search.")

from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

from tools import llm, rag_tool, calculator, search  # Import depuis tools.py

tools = [rag_tool, calculator, search]

# Prompt ReAct optimisé pour Agentic RAG
prompt = hub.pull("hwchase17/react")
prompt.messages[0].prompt.template = """
Tu es un agent expert en RAG. Pour toute query liée à RAG/agents, utilise d'abord rag_search.
Si besoin de calcul, calculator. Pour info externe, search.
Raisonnement étape par étape, puis Final Answer.
{tools}
{agent_scratchpad}
"""

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# Test
result = agent_executor.invoke({"input": "Explique Agentic RAG et calcule 15% de 250k."})
print(result["output"])

from langchain_experimental.agents import ReflexionZeroAgent
from langchain_core.prompts import ChatPromptTemplate

from tools import llm, tools  # rag_tool, calculator, search

# Prompt réflexif
reflexion_prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un agent réflexif. Réfléchis sur tes actions passées pour améliorer. Critique : pertinent ? Complet ?"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

# Agent ReflexionZero (multi-hop + self-critique)
agent = ReflexionZeroAgent(
    llm=llm,
    tools=tools,
    reflection_prompt=reflexion_prompt,
    max_iterations=4,  # Limite pour éviter boucles infinies
    max_reflection=2
)

# Exécution
result = agent.run("Analyse multi-étapes : Quel est l'impact d'Agentic RAG sur les coûts LLM ? Estime pour 1M queries (coût embed=0.0001$/1k tokens).")
print(result)

import streamlit as st
import os
from dotenv import load_dotenv
from basic_agent import agent_executor  # Ou advanced_agent

load_dotenv()

st.title("🧠 Agentic RAG Demo")
query = st.text_input("Posez votre question complexe :")

if st.button("Exécuter") and query:
    with st.spinner("L'agent raisonne..."):
        result = agent_executor.invoke({"input": query})
    st.success("Réponse :")
    st.write(result["output"])

# Lancer : streamlit run app.py