{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-giovannipasq--agentic-rag-for-dummies","slug":"giovannipasq--agentic-rag-for-dummies","name":"agentic-rag-for-dummies","type":"repo","url":"https://github.com/GiovanniPasq/agentic-rag-for-dummies","page_url":"https://unfragile.ai/giovannipasq--agentic-rag-for-dummies","categories":["rag-knowledge"],"tags":["agent","agentic-ai","agentic-rag","agents","ai-agents","bm25","generative-ai","gradio","langchain","langgraph","llm","ollama","qdrant","rag","rag-agents","rag-chatbot","rag-pipeline","retrieval-augmented-generation","retrieval-augmented-generation-rag"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_0","uri":"capability://data.processing.analysis.hierarchical.parent.child.document.chunking.with.dual.embedding.indexing","name":"hierarchical parent-child document chunking with dual-embedding indexing","description":"Splits PDF documents into small child chunks (512 tokens) nested within larger parent chunks (2048 tokens), then indexes both layers separately using dense embeddings (sentence-transformers) and sparse BM25 embeddings via FastEmbedSparse. At retrieval time, the system fetches child chunks for precision but returns their parent context for completeness, solving the precision-vs-context tradeoff inherent in flat RAG systems. This two-tier indexing strategy is orchestrated through a DocumentChunker and VectorDatabaseManager that maintains parent-child relationships in Qdrant.","intents":["I want to retrieve precise answer snippets without losing surrounding context that explains them","I need my RAG system to handle both keyword-based and semantic search without separate indices","I want to reduce hallucinations by grounding responses in full parent document context, not isolated fragments"],"best_for":["teams building production RAG systems where context loss causes answer quality degradation","developers working with long-form documents (research papers, technical specs, legal contracts) where isolated chunks lack meaning"],"limitations":["Requires maintaining parent-child relationships in vector store, adding ~15-20% storage overhead vs flat chunking","Parent chunk retrieval adds ~50-100ms latency per query due to secondary lookup after child chunk retrieval","Chunk size tuning (512/2048 tokens) is dataset-specific; no automatic optimization provided"],"requires":["Python 3.10+","Qdrant vector database (in-process or remote)","sentence-transformers library 5.2.0+","fastembed 0.7.4+ for BM25 sparse embeddings"],"input_types":["PDF documents","text content (pre-extracted from PDFs)"],"output_types":["indexed vector embeddings (dense + sparse)","parent-child chunk metadata stored in Qdrant"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_1","uri":"capability://planning.reasoning.agentic.multi.turn.query.reasoning.with.langgraph.state.machine","name":"agentic multi-turn query reasoning with langgraph state machine","description":"Orchestrates a multi-node LangGraph workflow where an LLM-powered agent reasons about user queries, decides whether to retrieve documents, clarifies ambiguous questions via human-in-the-loop prompts, and iteratively refines search strategies based on retrieval results. The graph implements conditional routing (via graph.add_conditional_edges) to branch between retrieval, clarification, and response generation nodes. State is maintained across turns in a TypedDict that tracks conversation history, retrieved documents, and agent decisions, enabling the agent to learn from previous retrieval failures and adjust its approach.","intents":["I want my RAG system to ask clarifying questions when a user query is ambiguous, rather than returning irrelevant results","I need the agent to decide when retrieval is necessary vs when it can answer from its training knowledge","I want multi-turn conversations where the agent remembers previous context and refines its retrieval strategy based on what it learned"],"best_for":["developers building conversational AI agents that need reasoning capabilities beyond simple retrieval","teams deploying RAG systems where query ambiguity is common and user clarification improves accuracy"],"limitations":["Each agent reasoning step adds ~1-3 seconds latency (LLM inference time) compared to direct retrieval","Requires LLMs with strong tool-calling support (7B+ parameters recommended); smaller models may ignore retrieval instructions","State management requires in-memory or persistent storage; no built-in distributed state backend for multi-instance deployments"],"requires":["LangGraph 1.0.5+","LLM with function-calling capability (OpenAI, Anthropic, Ollama 7B+)","Python 3.10+ for TypedDict state definitions"],"input_types":["user query (text)","conversation history (list of messages)"],"output_types":["agent decision (retrieve/clarify/respond)","clarification prompt (text)","final response (text with citations)"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_10","uri":"capability://data.processing.analysis.document.indexing.pipeline.with.batch.processing.and.incremental.updates","name":"document indexing pipeline with batch processing and incremental updates","description":"Processes PDF documents through a multi-stage pipeline: PDF-to-text conversion (with smart routing), hierarchical chunking (parent-child), embedding generation (dense + sparse), and storage in Qdrant. The DocumentManager orchestrates this pipeline, supporting batch indexing of multiple documents and incremental updates (adding new documents without re-indexing existing ones). The pipeline is modular, enabling custom PDF processing strategies or embedding models to be swapped without changing the core indexing logic.","intents":["I want to index a batch of PDFs into my RAG system without manual per-document configuration","I need to add new documents to an existing index without re-processing previously indexed documents","I want a modular indexing pipeline where I can swap PDF processing or embedding strategies"],"best_for":["teams building document management systems with RAG capabilities","organizations with growing document collections that need incremental indexing"],"limitations":["Batch processing is sequential; no parallelization across documents, limiting throughput for large batches","Incremental updates require tracking document versions; no built-in deduplication or update detection","Embedding generation is the bottleneck; dense embeddings for large documents can take minutes per document"],"requires":["Python 3.10+","Qdrant vector database","sentence-transformers for dense embeddings","fastembed for sparse embeddings"],"input_types":["PDF files (local or remote)","document metadata (title, source, etc.)"],"output_types":["indexed documents in Qdrant","document metadata stored in parent store"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_11","uri":"capability://memory.knowledge.vector.database.abstraction.with.qdrant.backend.and.parent.child.relationship.management","name":"vector database abstraction with qdrant backend and parent-child relationship management","description":"Abstracts vector database operations (insert, search, delete) behind a VectorDatabaseManager class that handles both dense and sparse vector storage in Qdrant. The manager maintains parent-child chunk relationships using Qdrant's metadata filtering, enabling retrieval of child chunks while returning parent context. Supports both in-process (local) and remote Qdrant instances, enabling development on local machines and production on cloud deployments without code changes.","intents":["I want to abstract vector database operations so I can swap backends (Qdrant, Pinecone, Weaviate) without changing agent code","I need to maintain parent-child chunk relationships in my vector store for hierarchical retrieval","I want to support both local development (in-process Qdrant) and cloud production (remote Qdrant) with the same codebase"],"best_for":["teams building production RAG systems that may need to scale to cloud deployments","developers wanting to experiment with different vector databases without rewriting retrieval logic"],"limitations":["Qdrant-specific implementation; swapping backends requires rewriting VectorDatabaseManager","In-process Qdrant has memory limits; not suitable for very large document collections (> 1M chunks)","Remote Qdrant adds network latency (~50-200ms per query) vs in-process storage"],"requires":["Qdrant 1.16.2+ (in-process or remote)","qdrant-client 1.16.2+","langchain-qdrant 1.1.0+ for LangChain integration"],"input_types":["dense embeddings (1536-dim for sentence-transformers)","sparse embeddings (BM25 vectors)","chunk metadata (parent ID, source, etc.)"],"output_types":["search results (ranked chunks with scores)","metadata (parent chunk references, source documents)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_12","uri":"capability://text.generation.language.notebook.based.tutorial.with.interactive.cells.for.learning.rag.concepts","name":"notebook-based tutorial with interactive cells for learning rag concepts","description":"Provides a Jupyter notebook that walks through RAG concepts step-by-step: document loading, chunking, embedding, retrieval, and agent workflows. Each cell is self-contained and executable, enabling learners to understand concepts incrementally and experiment with parameters (chunk sizes, embedding models, LLM providers). The notebook includes visualizations of the indexing pipeline and agent graph, making abstract concepts concrete. This is distinct from the production modular system, serving as an educational tool rather than a deployment artifact.","intents":["I want to learn how RAG systems work by running code examples and seeing results","I need to understand the impact of different chunk sizes, embedding models, and retrieval strategies on answer quality","I want to experiment with different LLM providers without setting up a full production system"],"best_for":["students and junior developers learning RAG concepts","teams evaluating RAG approaches before committing to production implementation"],"limitations":["Notebook is not suitable for production deployments; no error handling, logging, or monitoring","All state is in-memory; restarting the kernel loses indexed documents and conversation history","Notebook execution is sequential; no parallelization or optimization for large document collections"],"requires":["Jupyter notebook environment","Python 3.10+","all dependencies from requirements.txt"],"input_types":["PDF files (provided in notebook)","user queries (text input in notebook cells)"],"output_types":["indexed documents (in-memory)","retrieval results (displayed in notebook)","agent responses (streamed in notebook)"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_2","uri":"capability://planning.reasoning.human.in.the.loop.clarification.prompting.for.ambiguous.queries","name":"human-in-the-loop clarification prompting for ambiguous queries","description":"Implements a dedicated agent node that detects ambiguous or under-specified user queries and generates clarification prompts asking the user to provide additional context (e.g., 'Which department's budget are you asking about?'). The clarification node is triggered via conditional routing when the agent's reasoning indicates insufficient query specificity. User responses are appended to the conversation state and the query is re-processed with the clarified context, enabling iterative refinement without requiring the user to restart the conversation.","intents":["I want to avoid retrieving irrelevant documents by asking users to clarify vague queries before searching","I need a way to handle multi-interpretation queries (e.g., 'What is the policy?' could refer to multiple policies) without guessing","I want to improve answer quality by collecting necessary context upfront rather than returning low-confidence results"],"best_for":["customer support and knowledge base systems where query ambiguity is frequent","enterprise RAG deployments where incorrect answers are costly and clarification is acceptable UX"],"limitations":["Adds user interaction latency; not suitable for fully automated systems requiring immediate responses","Requires LLM to reliably detect ambiguity; smaller models may miss subtle ambiguities or over-clarify simple queries","No built-in heuristics for determining when clarification is necessary; relies entirely on LLM judgment"],"requires":["LangGraph 1.0.5+","LLM with instruction-following capability (7B+ parameters)","interactive UI layer (Gradio or custom) to display clarification prompts and collect user input"],"input_types":["user query (text)","conversation history"],"output_types":["clarification prompt (text)","clarified query (text after user response)"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_3","uri":"capability://data.processing.analysis.multi.strategy.pdf.to.text.conversion.with.smart.routing","name":"multi-strategy pdf-to-text conversion with smart routing","description":"Implements three PDF processing strategies (simple text extraction via PyMuPDF4LLM, OCR+table detection for medium-complexity PDFs, and vision-language model analysis for complex layouts) with automatic routing based on PDF characteristics. The DocumentManager analyzes PDF structure (text density, table presence, image complexity) and selects the appropriate strategy, falling back to simpler methods if advanced processing fails. This avoids unnecessary computation (vision models are expensive) while ensuring complex PDFs are handled correctly.","intents":["I want to process PDFs with mixed content (text, tables, images) without manual strategy selection","I need fast PDF processing for simple documents but robust handling for complex layouts without manual intervention","I want to avoid expensive vision-model calls for PDFs that can be handled with simpler text extraction"],"best_for":["document processing pipelines handling heterogeneous PDF sources (scanned documents, reports, mixed layouts)","cost-conscious teams using vision APIs (Claude, GPT-4V) who want to minimize API calls"],"limitations":["Automatic routing heuristics are rule-based and may misclassify PDFs; no machine learning-based strategy selection","Vision-language model fallback requires API credentials and incurs per-document costs (~$0.01-0.10 per page)","OCR quality varies by language and font; non-Latin scripts may require additional configuration"],"requires":["pymupdf4llm 0.2.9+ for text extraction","pytesseract or similar for OCR (optional, for medium-complexity PDFs)","API credentials for vision models (Claude, GPT-4V) if using advanced strategy","Python 3.10+"],"input_types":["PDF files (local or remote)"],"output_types":["markdown text (extracted and formatted)","structured metadata (tables, images, layout info)"],"categories":["data-processing-analysis","image-visual"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_4","uri":"capability://search.retrieval.two.stage.retrieval.with.dense.sparse.hybrid.search","name":"two-stage retrieval with dense-sparse hybrid search","description":"Combines dense vector embeddings (sentence-transformers) and sparse BM25 embeddings (FastEmbedSparse) in a two-stage retrieval pipeline: first, both dense and sparse searches are executed in parallel against Qdrant, then results are merged using reciprocal rank fusion (RRF) to balance semantic relevance and keyword matching. This hybrid approach retrieves child chunks for ranking but returns parent chunks for generation, addressing both semantic gaps (where BM25 fails) and keyword-specific queries (where dense embeddings alone miss exact matches).","intents":["I want retrieval that handles both semantic queries ('What is the company's strategy?') and keyword queries ('Find section 3.2 on compliance')","I need to reduce false negatives where dense embeddings miss exact terminology matches that are semantically relevant","I want a single retrieval call that balances semantic and lexical relevance without maintaining separate indices"],"best_for":["technical documentation RAG systems where both semantic understanding and exact terminology matching are critical","enterprise knowledge bases with mixed query types (natural language + specific section references)"],"limitations":["Parallel dense+sparse search adds ~100-200ms latency vs single-strategy retrieval","RRF merging requires tuning of weighting parameters; no automatic optimization provided","BM25 effectiveness depends on document language and terminology; poor results for highly technical jargon without custom tokenization"],"requires":["Qdrant 1.16.2+ with support for both dense and sparse vector search","sentence-transformers 5.2.0+ for dense embeddings","fastembed 0.7.4+ for BM25 sparse embeddings","langchain-qdrant 1.1.0+ for integration"],"input_types":["user query (text)"],"output_types":["ranked list of parent chunks with relevance scores","metadata including child chunk references and retrieval strategy (dense/sparse/hybrid)"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_5","uri":"capability://memory.knowledge.conversation.memory.management.with.multi.turn.context.preservation","name":"conversation memory management with multi-turn context preservation","description":"Maintains conversation history in the LangGraph state (TypedDict with messages list) across multiple turns, enabling the agent to reference previous queries, clarifications, and retrieved documents when answering new questions. The state includes full message history with roles (user/assistant) and metadata (retrieved documents, agent decisions), allowing the LLM to generate contextually aware responses that acknowledge prior context. Conversation state is passed to every agent node, enabling consistent reasoning across turns without requiring external memory systems.","intents":["I want the agent to remember previous questions and answers so follow-up queries like 'Tell me more about that' work correctly","I need to track which documents were retrieved for each question to provide consistent citations across turns","I want the agent to learn from previous retrieval failures and adjust its strategy in subsequent turns"],"best_for":["conversational RAG systems where users ask follow-up questions and expect context awareness","customer support chatbots where conversation history is critical for accurate responses"],"limitations":["In-memory state management; conversation history is lost on process restart without external persistence","No automatic context compression; long conversations may exceed LLM context windows (requires manual pruning or summarization)","State size grows linearly with conversation length; no built-in garbage collection for old messages"],"requires":["LangGraph 1.0.5+ with TypedDict state support","Python 3.10+ for type hints","optional: external persistence layer (database, cache) for production deployments"],"input_types":["user message (text)","previous conversation state"],"output_types":["updated conversation state with new message","agent response with context awareness"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_6","uri":"capability://tool.use.integration.schema.based.tool.calling.with.multi.provider.llm.support","name":"schema-based tool calling with multi-provider llm support","description":"Defines retrieval tools as Pydantic schemas (e.g., RetrievalTool with query and filters parameters) and exposes them to the LLM via function-calling APIs. The system abstracts provider-specific function-calling implementations (OpenAI, Anthropic, Ollama) behind a unified LangChain interface, enabling the agent to invoke retrieval tools without knowing the underlying LLM provider. Tool schemas include descriptions and parameter constraints, allowing the LLM to understand when and how to use retrieval.","intents":["I want the LLM to decide when to retrieve documents and what query to use, rather than always retrieving","I need to support multiple LLM providers (OpenAI, Anthropic, Ollama) without rewriting agent code","I want type-safe tool definitions that prevent invalid retrieval parameters from being passed to the system"],"best_for":["developers building provider-agnostic agents that need to switch LLMs without code changes","teams using multiple LLM providers and wanting consistent tool-calling behavior across them"],"limitations":["Tool-calling reliability varies by LLM; smaller models (< 7B) may ignore tool schemas or generate invalid parameters","Function-calling overhead adds ~200-500ms per tool invocation vs direct function calls","Provider-specific quirks (e.g., Anthropic's tool_use block format) require abstraction layers that may leak implementation details"],"requires":["LangChain 1.2.3+ with tool-calling support","LLM with function-calling capability (OpenAI, Anthropic, Ollama 7B+)","Pydantic 2.0+ for schema definitions","provider-specific SDK (langchain-openai, langchain-anthropic, etc.)"],"input_types":["tool schema (Pydantic model)","LLM response with tool calls"],"output_types":["tool invocation with parameters","tool result (retrieved documents, etc.)"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_7","uri":"capability://automation.workflow.gradio.web.ui.with.streaming.response.generation","name":"gradio web ui with streaming response generation","description":"Provides a Gradio-based chat interface that streams agent responses token-by-token to the user, displaying retrieved documents and agent reasoning steps in real-time. The UI integrates with the LangGraph agent, passing user messages to the graph and rendering outputs (responses, clarification prompts, document citations) as they are generated. Streaming is implemented via LangChain's streaming callbacks, reducing perceived latency by showing partial responses while the LLM is still generating.","intents":["I want a user-friendly chat interface for my RAG agent without building a custom frontend","I need to show users what documents were retrieved and how the agent reasoned about their query","I want streaming responses so users see answers appearing in real-time rather than waiting for full generation"],"best_for":["rapid prototyping and demos of RAG agents","non-technical users who need a simple chat interface without custom frontend development"],"limitations":["Gradio is not suitable for production deployments at scale; limited customization and no built-in authentication","Streaming adds complexity to state management; requires careful handling of concurrent requests","No built-in support for rich media (images, tables) in responses; markdown rendering is basic"],"requires":["Gradio 6.3.0+","LangChain 1.2.3+ with streaming callback support","Python 3.10+"],"input_types":["user text input (chat message)"],"output_types":["streamed text response","retrieved documents (markdown)","agent reasoning steps (optional)"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_8","uri":"capability://automation.workflow.configuration.driven.system.setup.with.environment.based.provider.selection","name":"configuration-driven system setup with environment-based provider selection","description":"Centralizes system configuration (LLM provider, model names, chunk sizes, vector database settings) in a configuration module that reads from environment variables and YAML files. This enables switching between Ollama, OpenAI, Anthropic, and Google Gemini by changing a single environment variable (LLM_PROVIDER) without modifying code. Configuration is loaded at startup and passed through the application, enabling runtime provider switching and easy customization for different deployment scenarios (local development vs cloud production).","intents":["I want to switch between local (Ollama) and cloud (OpenAI) LLMs without changing code","I need to configure chunk sizes, embedding models, and retrieval parameters without editing source files","I want different configurations for development (local Ollama) and production (cloud API) deployments"],"best_for":["teams deploying RAG systems across multiple environments (dev, staging, production)","developers experimenting with different LLM providers and wanting quick switching"],"limitations":["Configuration validation is minimal; invalid settings may not be caught until runtime","No built-in secrets management; API keys must be stored in environment variables (requires external secret management for production)","Configuration changes require application restart; no hot-reload support"],"requires":["Python 3.10+","environment variables or YAML configuration files","optional: secret management system (AWS Secrets Manager, HashiCorp Vault) for production"],"input_types":["environment variables","YAML configuration files"],"output_types":["configuration object passed to application components"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-giovannipasq--agentic-rag-for-dummies__cap_9","uri":"capability://data.processing.analysis.token.aware.context.compression.with.conversation.pruning","name":"token-aware context compression with conversation pruning","description":"Uses tiktoken to count tokens in conversation history and automatically prunes old messages when approaching the LLM's context window limit. The system tracks token usage across retrieved documents, conversation history, and system prompts, and removes oldest messages (while preserving recent context) to stay within budget. This enables long conversations without exceeding context limits or requiring manual truncation, though it may lose distant conversation context.","intents":["I want long conversations without hitting LLM context window limits","I need to track token usage across my RAG system to optimize costs and latency","I want automatic context management without manually specifying which messages to keep"],"best_for":["conversational RAG systems with extended user interactions","cost-conscious deployments using token-based LLM pricing"],"limitations":["Pruning removes context; distant conversation history is lost, potentially causing inconsistencies in follow-up questions","Token counting is approximate (tiktoken is model-specific); actual token usage may vary by LLM","No intelligent summarization; old messages are simply discarded rather than compressed into summaries"],"requires":["tiktoken 0.12.0+","knowledge of LLM context window size (e.g., 4K, 8K, 128K tokens)"],"input_types":["conversation history (list of messages)","retrieved documents (text)"],"output_types":["pruned conversation history within token budget","token usage metrics"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":44,"verified":false,"data_access_risk":"high","permissions":["Python 3.10+","Qdrant vector database (in-process or remote)","sentence-transformers library 5.2.0+","fastembed 0.7.4+ for BM25 sparse embeddings","LangGraph 1.0.5+","LLM with function-calling capability (OpenAI, Anthropic, Ollama 7B+)","Python 3.10+ for TypedDict state definitions","Qdrant vector database","sentence-transformers for dense embeddings","fastembed for sparse embeddings"],"failure_modes":["Requires maintaining parent-child relationships in vector store, adding ~15-20% storage overhead vs flat chunking","Parent chunk retrieval adds ~50-100ms latency per query due to secondary lookup after child chunk retrieval","Chunk size tuning (512/2048 tokens) is dataset-specific; no automatic optimization provided","Each agent reasoning step adds ~1-3 seconds latency (LLM inference time) compared to direct retrieval","Requires LLMs with strong tool-calling support (7B+ parameters recommended); smaller models may ignore retrieval instructions","State management requires in-memory or persistent storage; no built-in distributed state backend for multi-instance deployments","Batch processing is sequential; no parallelization across documents, limiting throughput for large batches","Incremental updates require tracking document versions; no built-in deduplication or update detection","Embedding generation is the bottleneck; dense embeddings for large documents can take minutes per document","Qdrant-specific implementation; swapping backends requires rewriting VectorDatabaseManager","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5526943071880209,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:58:29.528Z","last_commit":"2026-04-25T19:46:40Z"},"community":{"stars":3195,"forks":430,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=giovannipasq--agentic-rag-for-dummies","compare_url":"https://unfragile.ai/compare?artifact=giovannipasq--agentic-rag-for-dummies"}},"signature":"YwNNg5onIYWjHe8Oq0TCpde1jGaualsDvgF598q9NK39aWAFedS49DKitwGtsZCi34HW/XASnO+7LPQ+5jVdDg==","signedAt":"2026-06-21T03:02:15.062Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/giovannipasq--agentic-rag-for-dummies","artifact":"https://unfragile.ai/giovannipasq--agentic-rag-for-dummies","verify":"https://unfragile.ai/api/v1/verify?slug=giovannipasq--agentic-rag-for-dummies","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}