Register and share your invite link to earn from video plays and referrals.

Search results for RAG_FINALE
RAG_FINALE community
One keyword maps to one global community path.
Create community
People
Not Found
Tweets including RAG_FINALE
The OCI Agent Evaluation Framework goes beyond final-answer scoring to evaluate prompts, RAG, tools, trajectories, state changes, and production behavior across the agent lifecycle. Learn more:
Show more
📚 Wouldn't it be great to run ReAct, RAG, and Tree of Thoughts behind one API and compare them, instead of wrangling scattered per-paper implementations? This repo delivers exactly that, with all 35 patterns in one place. Title: FareedKhan-dev/all-agentic-architectures URL: 📦 Overview This is a Python library and a "living textbook" implementing 35 production-grade agentic AI patterns. Every architecture exposes the same .run(task) method and returns an identical result shape, so you can swap patterns without touching downstream code. ❓ Challenges Solved Agentic design patterns have been scattered across papers, each with its own implementation and conventions. The real value here is unifying them under a single interface so you can try them side by side. 💡 Core Idea & Approach The central idea is the "deterministic-picker discipline." ・Instead of handing scoring entirely to the LLM, it first has the LLM commit to categorical features like booleans and enums ・The final decision is then composed in Python logic This mitigates the flat-band pathology of LLM-as-Scorer, and it appears in 13 of the 35 architectures. 🎯 Coverage & Use Cases It spans eight families: reasoning and reflection (Reflection, Self-Discover), search (Tree of Thoughts, LATS), RAG (Corrective/Self/Adaptive/GraphRAG), memory (MemGPT, Voyager), tools and actions (ReAct, SWE-Agent), and multi-agent (Debate, STORM). Each pattern ships with an executed Jupyter notebook, giving reproducible references grounded in real LLM output. 📊 Highlights ・Built on LangGraph, with support for Nebius, OpenAI, Anthropic, Ollama and more, switchable via a single env var ・283 passing pytest tests ・On a 17-task benchmark it recently scored 33/42 correct (78%), with Reflection and Self-Consistency among the strongest #AIAgents# #LangGraph#
Show more
# Practical and Useful Patterns with ADK 📏 What you measure determines the quality of your evaluation. ADK's Evaluation Criteria provide built-in metrics covering tool trajectory accuracy, hallucination detection, safety assessment, and multi-turn task success. 📌 Title: Evaluation Criteria 🔗 URL: 🧩 Overview ADK provides multiple built-in evaluation criteria, all returning scores normalized to 0.0-1.0. **tool_trajectory_avg_score** verifies agent tool call sequences. **response_match_score** measures response similarity via ROUGE-1. **hallucinations_v1** validates response grounding against context. **safety_v1** assesses harmful content. **multi_turn_task_success_v1** measures task completion across conversation turns. 🛠 Usage Each criterion is configured in a JSON configuration file. **tool_trajectory_avg_score** — choose from three match types: ```json { "criteria": { "tool_trajectory_avg_score": { "threshold": 1.0, "match_type": "EXACT" } } } ``` - `EXACT`: Perfect match required — no extra or missing tool calls - `IN_ORDER`: Expected tools must appear in sequence, but other calls between them are allowed - `ANY_ORDER`: All expected tools must be present, regardless of order **response_match_score** — ROUGE-1 unigram overlap: ```json { "criteria": { "response_match_score": 0.8 } } ``` **hallucinations_v1** — validates each sentence against provided context: ```json { "criteria": { "hallucinations_v1": { "threshold": 0.8, "judge_model_options": { "judge_model": "gemini-flash-latest" }, "evaluate_intermediate_nl_responses": true } } } ``` Each sentence receives a label: supported, unsupported, contradictory, disputed, or not_applicable. The score is the percentage of sentences labeled supported or not_applicable. **safety_v1** — evaluates for hate speech, harassment, and dangerous information: ```json { "criteria": { "safety_v1": 0.8 } } ``` **multi_turn_task_success_v1** — measures task achievement across a full conversation: ```json { "criteria": { "multi_turn_task_success_v1": 0.8 } } ``` 🏗 Practical Patterns **Strict Tool Trajectory Verification**: In domains like finance or healthcare where tool call order matters — such as "authenticate first, check balance, then transfer" — use `EXACT` match to ensure the agent follows correct procedures. **Flexible Tool Verification**: For exploratory tasks, use `ANY_ORDER` to verify all necessary tools were called. `IN_ORDER` fits cases where main step order must be preserved but auxiliary tool calls between them are acceptable. **Hallucination Detection in Practice**: Use `hallucinations_v1` with RAG-based agents to automatically detect when agents generate information not grounded in retrieved results. Enable `evaluate_intermediate_nl_responses` to validate not just final answers but intermediate responses too. **Balancing Safety and Task Success**: Combine `safety_v1` with `multi_turn_task_success_v1` to catch agents that are "safe but ineffective" or "effective but inappropriate." 💡 Use Cases 🎯 Strict tool call order verification for finance/healthcare agents 🔍 Automatic hallucination detection in RAG agents 🛡 Safety evaluation for customer support agents 📈 Quantitative task completion rate measurement in multi-turn dialogues ⚠️ Caveats - `safety_v1`, `multi_turn_task_success_v1`, `multi_turn_trajectory_quality_v1`, and `multi_turn_tool_use_quality_v1` require Google Cloud Project setup (`GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` environment variables). - LLM-based criteria can vary between judge model runs. Set `num_samples` for multiple sampling with majority voting to stabilize results. - `response_match_score` uses ROUGE-1 (word overlap only) and does not evaluate semantic equivalence. Consider `final_response_match_v2` for semantic evaluation. ✨ Choosing the right evaluation criteria is the foundation of agent quality management. Match EXACT/IN_ORDER/ANY_ORDER to your domain requirements, and combine hallucination detection with safety assessment for comprehensive quality assurance! #ADK# #AIAgent#
Show more
RAG and agent memory get used as synonyms. They aren't. RAG reads from a corpus that someone else wrote: docs, a wiki, a product catalogue. The agent only reads. Agent memory starts when the agent writes back: → a preference the user mentioned → the outcome of a task it just finished → a correction someone made to its answer Writing back changes the problem. You now decide what is worth keeping. You merge the new fact with what's already stored, and you handle the old fact it contradicts. Cognee's agent memory guide puts it in one line: "The moment your system starts writing back — capturing facts, recording previous interactions, or storing the outcomes of its own work — you've moved beyond RAG into agentic memory." Read-only retrieval is a search problem. Read-write retrieval is a data-management problem. Read more here:
Show more
RAG's "more precision means more latency" dilemma, tackled by using topics as a compass 🧭 Title: MCompassRAG: Topic Metadata as a Semantic Compass for Paragraph-Level Retrieval URL: 🧭 Overview A metadata-guided retrieval framework that uses topic-level signals as a "semantic compass" to select relevant evidence at the paragraph level. It aims to improve precision and efficiency at the same time. ❓ Challenges Solved RAG faces a precision-vs-efficiency trade-off. ・Fine-grained chunks raise precision but increase candidates, latency, and cost ・Larger chunks reduce candidates but introduce semantic noise from mixed topics This is acute in deep-research tasks needing fast, precise retrieval over large datasets. 💡 Methodology & Proposed Approach ・It enriches chunk representations with topic metadata within the same embedding space ・It uses LLM-teacher distillation to train a lightweight retriever ・This enables topic-aware retrieval with no additional LLM calls at inference time The core is combining metadata with dense embeddings and distilling into a lightweight retriever. 📊 Experimental Results ・Information efficiency: 8.24% average improvement across six benchmarks ・Latency: over 5x lower than the strongest efficient RAG baselines ・Code is available in a public repository It achieves this precision-and-speed balance without extra LLM calls at inference. #RAG# #Retrieval#
Show more
Enterprise RAG needs more than vectors. Hologres stores searchable text with embeddings, uses HGraph for vector retrieval, queries relationships with Cypher, and composes results with SQL. Break free from single-retrieval limits. Deliver a complete "decision evidence package" to significantly boost search efficiency in complex scenarios and elevate business decision-making. 🚀📊 #RAG# #Hologres# #MultiModalSearch#
Show more
Great RAG paper from IBM. There are some really good ideas on how to solve common RAG issues. It's well known that retrievers chunk long documents by length, which discards the hierarchy the document already has. So they propose using a table of contents. A table of contents helps to encodes exactly the global structure that chunking throws away. STAIR uses that table of contents as the addressing scheme for a generative retriever, so the model stores and retrieves information from its own parameters against a structure the corpus supplies. On SearchTome, it reaches Recall@1 of 82.6 percent against 76.9 percent for a fine-tuned Differentiable Search Index, a statistically significant gap, with BM25 at 59.5 percent and DPR at 68.7 percent. Hallucination stays below 0.05 percent, which is the standing objection to generative retrieval and the reason grounding the address space in a real hierarchy is worth the extra structure. The ablations also show it generalizes where very few training samples exist. Paper:
Show more
Cutting RAG inference costs 6x starts with deciding what never reaches the LLM