skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
latestaiagents/agent-skills83 installs

agentic-rag

Build agentic RAG systems with autonomous planning, reflection, and tool use. Use this skill when implementing agent-driven retrieval, query decomposition, iterative refinement, or multi-source RAG orchestration. Activate when: agentic RAG, A-RAG, autonomous retrieval, query planning, iterative RAG, multi-step retrieval, agent retrieval, RAG agent.

How do I install this agent skill?

npx skills add https://github.com/latestaiagents/agent-skills --skill agentic-rag
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The skill provides a secure guide and code templates for building Agentic RAG systems. It incorporates security best practices, such as citing sources and using read-only tools, to mitigate risks like indirect prompt injection.

  • Socketpass

    No alerts

  • Snykwarn

    Risk: MEDIUM · 1 issue

  • Runlayerwarn

    1/1 file flagged

  • ZeroLeakspass

    2 findings · Score: 80/100

What does this agent skill do?

Agentic RAG Patterns

Let agents autonomously plan, retrieve, reflect, and refine for complex queries.

What Makes RAG "Agentic"

Traditional RAG: Query → Retrieve → Generate (one-shot)

Agentic RAG adds:

  • Planning: Decompose complex queries into sub-queries
  • Tool Use: Choose between multiple retrieval sources
  • Reflection: Evaluate if retrieved context is sufficient
  • Iteration: Refine queries and re-retrieve if needed

Core Architecture

┌─────────────────────────────────────────────────────────────┐
│                      User Query                              │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Query Planner                             │
│         "Break this into retrievable sub-queries"            │
└─────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
        ┌──────────┐   ┌──────────┐   ┌──────────┐
        │ SubQ 1   │   │ SubQ 2   │   │ SubQ 3   │
        └──────────┘   └──────────┘   └──────────┘
              │               │               │
              ▼               ▼               ▼
┌─────────────────────────────────────────────────────────────┐
│                    Tool Router                               │
│         "Which source for each sub-query?"                   │
└─────────────────────────────────────────────────────────────┘
              │               │               │
              ▼               ▼               ▼
        ┌──────────┐   ┌──────────┐   ┌──────────┐
        │ VectorDB │   │ Web API  │   │ SQL DB   │
        └──────────┘   └──────────┘   └──────────┘
              │               │               │
              └───────────────┼───────────────┘
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Reflection                                │
│         "Is this context sufficient to answer?"              │
│         → No: Refine query, re-retrieve                     │
│         → Yes: Generate answer                               │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Response Generation                       │
└─────────────────────────────────────────────────────────────┘

Pattern 1: Query Decomposition

Model IDs: CHAT_MODEL in these examples is a placeholder. Set it to a current chat model ID from your provider's models page (for example CHAT_MODEL = os.environ["CHAT_MODEL"]); model IDs are retired over time.

import json
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

DECOMPOSITION_PROMPT = """You are a query planner. Break down complex queries into simpler sub-queries.

Original query: {query}

Rules:
1. Each sub-query should be answerable independently
2. Sub-queries should cover all aspects of the original query
3. Return 2-5 sub-queries maximum
4. Return as JSON array

Example:
Query: "Compare Tesla and Ford's EV strategies and market performance"
Sub-queries: [
  "What is Tesla's electric vehicle strategy?",
  "What is Ford's electric vehicle strategy?",
  "What is Tesla's market performance and stock price?",
  "What is Ford's market performance and stock price?"
]

Sub-queries:"""

async def decompose_query(query: str, llm: ChatOpenAI) -> list[str]:
    """Break complex query into sub-queries."""
    prompt = ChatPromptTemplate.from_template(DECOMPOSITION_PROMPT)
    chain = prompt | llm
    result = await chain.ainvoke({"query": query})
    return json.loads(result.content)

Pattern 2: Tool-Based Routing

In LangChain 1.x, create_agent replaces the older AgentExecutor / create_openai_tools_agent pair (those now live in the langchain-classic package). Each retrieval source becomes a tool; the tool docstring is what the model reads when it picks a source.

from langchain.agents import create_agent
from langchain.tools import tool

@tool
def company_docs(query: str) -> str:
    """Search internal company documentation. Use for policies, procedures, internal info."""
    return format_docs(vector_store_company.similarity_search(query, k=5))

@tool
def product_catalog(query: str) -> str:
    """Search the product database. Use for product specs, pricing, availability."""
    return sql_product_search(query)  # parameterized, read-only queries only

@tool
def web_search(query: str) -> str:
    """Search the web. Use for current events and external information."""
    return tavily_search(query)

@tool
def knowledge_graph(query: str) -> str:
    """Query the knowledge graph. Use for relationships between entities."""
    return graph_query(query)

agent = create_agent(
    model=ChatOpenAI(model=CHAT_MODEL),  # or a "provider:model" string
    tools=[company_docs, product_catalog, web_search, knowledge_graph],
    system_prompt=(
        "Answer using the tools. Cite the source of every fact. "
        "If no tool returns relevant information, say so instead of guessing."
    ),
)

result = agent.invoke({"messages": [
    {"role": "user", "content": "What's our return policy and how does it compare to Amazon's?"}
]})
answer = result["messages"][-1].content
# Expected routing: company_docs for the policy, web_search for the comparison

Give tools narrow, read-only capabilities. Do not expose a general eval() "calculator" or raw SQL execution: the model's tool input is untrusted text, and retrieved documents can carry prompt injection.

Pattern 3: LangGraph Agentic RAG

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    query: str
    sub_queries: list[str]
    retrieved_docs: Annotated[list, operator.add]
    reflection: str
    answer: str
    iteration: int

def plan_node(state: AgentState) -> AgentState:
    """Decompose query into sub-queries."""
    sub_queries = decompose_query(state["query"])
    return {"sub_queries": sub_queries}

def retrieve_node(state: AgentState) -> AgentState:
    """Retrieve docs for each sub-query."""
    docs = []
    for sq in state["sub_queries"]:
        results = retriever.invoke(sq)
        docs.extend(results)
    return {"retrieved_docs": docs}

def reflect_node(state: AgentState) -> AgentState:
    """Evaluate if context is sufficient."""
    prompt = f"""
    Query: {state['query']}
    Retrieved context: {state['retrieved_docs'][:5]}

    Is this context sufficient to answer the query?
    If not, what additional information is needed?

    Return JSON: {{"sufficient": true/false, "missing": "..."}}
    """
    reflection = llm.invoke(prompt)
    return {"reflection": reflection.content}

def should_continue(state: AgentState) -> str:
    """Decide whether to refine or generate."""
    reflection = json.loads(state["reflection"])
    if reflection["sufficient"] or state["iteration"] >= 3:
        return "generate"
    return "refine"

def refine_node(state: AgentState) -> AgentState:
    """Refine query based on reflection."""
    reflection = json.loads(state["reflection"])
    refined = f"{state['query']} Specifically: {reflection['missing']}"
    return {
        "sub_queries": [refined],
        "iteration": state["iteration"] + 1
    }

def generate_node(state: AgentState) -> AgentState:
    """Generate final answer."""
    context = "\n".join([d.page_content for d in state["retrieved_docs"]])
    prompt = f"Context: {context}\n\nQuery: {state['query']}\n\nAnswer:"
    answer = llm.invoke(prompt)
    return {"answer": answer.content}

# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("plan", plan_node)
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("reflect", reflect_node)
workflow.add_node("refine", refine_node)
workflow.add_node("generate", generate_node)

workflow.set_entry_point("plan")
workflow.add_edge("plan", "retrieve")
workflow.add_edge("retrieve", "reflect")
workflow.add_conditional_edges("reflect", should_continue, {
    "generate": "generate",
    "refine": "refine"
})
workflow.add_edge("refine", "retrieve")
workflow.add_edge("generate", END)

app = workflow.compile()

Pattern 4: Multi-Source Orchestration

class MultiSourceRAG:
    """Orchestrate retrieval across multiple sources."""

    def __init__(self, sources: dict):
        self.sources = sources  # {"name": retriever}
        self.router_llm = ChatOpenAI(model=CHAT_MODEL)

    async def retrieve(self, query: str) -> dict:
        # 1. Determine which sources to query
        routing_prompt = f"""
        Query: {query}

        Available sources:
        {list(self.sources.keys())}

        Which sources should be queried? Return as JSON array.
        """
        sources_to_query = json.loads(
            (await self.router_llm.ainvoke(routing_prompt)).content
        )

        # 2. Query selected sources in parallel
        tasks = []
        for source_name in sources_to_query:
            if source_name in self.sources:
                tasks.append(self._query_source(source_name, query))

        results = await asyncio.gather(*tasks)

        # 3. Combine and deduplicate
        combined = self._fuse_results(results)
        return combined

    async def _query_source(self, name: str, query: str):
        retriever = self.sources[name]
        docs = await retriever.ainvoke(query)
        return {"source": name, "docs": docs}

    def _fuse_results(self, results: list) -> list:
        # Deduplicate and rank
        seen = set()
        fused = []
        for r in results:
            for doc in r["docs"]:
                doc_hash = hash(doc.page_content[:100])
                if doc_hash not in seen:
                    seen.add(doc_hash)
                    doc.metadata["source"] = r["source"]
                    fused.append(doc)
        return fused

Pattern 5: Self-Reflective RAG

def self_reflective_rag(query: str, retriever, llm, max_iterations: int = 3):
    """RAG with self-reflection loop."""

    for i in range(max_iterations):
        # Retrieve
        docs = retriever.invoke(query)
        context = "\n".join([d.page_content for d in docs])

        # Generate with reflection request
        response = llm.invoke(f"""
        Context: {context}

        Query: {query}

        Provide your answer, then reflect:
        1. Does the context fully support your answer?
        2. What information might be missing?
        3. Confidence level (high/medium/low)?

        Format:
        ANSWER: ...
        REFLECTION: ...
        CONFIDENCE: ...
        MISSING: ...
        """)

        # Parse reflection
        if "CONFIDENCE: high" in response.content:
            return extract_answer(response.content)

        if "MISSING:" in response.content:
            # Refine query with missing info
            missing = extract_missing(response.content)
            query = f"{query} Also include: {missing}"

    return extract_answer(response.content)

Pattern 6: Retrieval Gate (Retrieve Only When Needed)

Some questions (arithmetic, rewriting the user's own text, small talk) do not need retrieval. A cheap classification step skips the retriever for them. Use structured output instead of substring checks: "RETRIEVE" in text also matches "NO_RETRIEVE".

from typing import Literal
from pydantic import BaseModel, Field

class RetrievalDecision(BaseModel):
    decision: Literal["retrieve", "no_retrieve"]
    reason: str = Field(description="One sentence")

gate = ChatOpenAI(model=CHAT_MODEL, temperature=0).with_structured_output(RetrievalDecision)

def needs_retrieval(question: str) -> bool:
    result = gate.invoke(
        "Does answering this question require facts from our documents or current data? "
        "Reasoning, math, or rewriting text the user supplied does not.\n\n"
        f"Question: {question}"
    )
    return result.decision == "retrieve"

When in doubt, retrieve: a wrong no_retrieve produces an ungrounded answer, while a wrong retrieve only costs one retrieval call.

Pattern 7: Adaptive Retrieval (Expand When Results Are Weak)

Check retrieval quality before generating. If the best result is weak, rephrase the query, retrieve again, deduplicate, and rerank.

def adaptive_retrieve(query: str, vectorstore, min_score: float, k: int = 5) -> list:
    """min_score is a threshold you calibrate on your own labeled queries."""
    results = vectorstore.similarity_search_with_relevance_scores(query, k=k)

    if not results or max(score for _, score in results) < min_score:
        for alt in expand_query(query):          # LLM-generated rephrasings
            results.extend(vectorstore.similarity_search_with_relevance_scores(alt, k=k))

    docs = deduplicate([doc for doc, _ in results])
    return rerank(query, docs)[:k]               # see hybrid-retrieval for rerankers

def expand_query(query: str) -> list[str]:
    llm = ChatOpenAI(model=CHAT_MODEL)
    response = llm.invoke(
        f"Write 3 alternative phrasings of this search query, one per line:\n{query}"
    )
    return [line.strip() for line in response.content.splitlines() if line.strip()][:3]

Relevance scores are not comparable across embedding models or vector stores, so set min_score from your own data rather than reusing a number from elsewhere.

Synthesis With Citations

Whatever the pattern, the final step should number the retrieved passages and ask for citations, so a reader (or an evaluator) can check each claim:

def synthesize(question: str, docs: list) -> str:
    numbered = "\n\n".join(
        f"[{i}] ({d.metadata.get('source', 'unknown')}) {d.page_content}"
        for i, d in enumerate(docs, 1)
    )
    prompt = (
        "Answer the question using only the numbered sources. Cite them as [1], [2]. "
        "If the sources do not contain the answer, say so.\n\n"
        f"Question: {question}\n\nSources:\n{numbered}"
    )
    return ChatOpenAI(model=CHAT_MODEL).invoke(prompt).content

Patterns Summary

PatternWhen to UseComplexity
Retrieval gateMixed traffic where many questions need no documentsLow
Adaptive retrievalRetrieval quality varies by queryMedium
Query decompositionMulti-part or comparison questionsMedium
Tool-based routingSeveral data sourcesHigh
Reflection loop (LangGraph)Research-style questionsHigh

Best Practices

  1. Start simple - Add planning, routing, or reflection only when single-pass RAG fails on your eval set
  2. Limit iterations - Cap loops (the examples use 3) so a bad reflection cannot loop forever
  3. Parallelize sub-queries - Use async for multiple retrievals
  4. Cache intermediate results - Don't re-retrieve the same content
  5. Log decisions - Record which tools were called, why, and how many iterations ran
  6. Validate outputs - Models can claim a tool result they never received; check citations against retrieved sources
  7. Track token usage - Agentic loops multiply LLM calls
  8. Provide fallbacks - If planning or reflection fails to parse, fall back to standard RAG

When to Use Agentic RAG

Query TypeStandard RAGAgentic RAG
Simple factual✅Overkill
Multi-part questions⚠️✅
Comparison queries❌✅
Research tasks❌✅
Multi-source needs❌✅

Performance Considerations

  • Latency: multiple LLM and retrieval round-trips, so noticeably slower than single-pass RAG
  • Cost: more tokens per query (planning, grading, re-retrieval)
  • Quality: can help on multi-hop or ambiguous queries; measure the gain on your own eval set before rolling it out

Use agentic patterns selectively for complex queries, not for everything.

References

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/latestaiagents/agent-skills/agentic-rag">View agentic-rag on skillZs</a>