Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

We've created a comprehensive Retrieval Harness for modern agentic retrieval in 2026. The harness provides a persistent data pipeline that can connect to a data source, index and update a large knowledge base, and expose a broad set of tools akin to filesystem operations (semantic/keyword search, regex grep, file...

57,194 görüntüleme • 3 ay önce •via X (Twitter)

24 Yorum

Adnan Qidwai profil fotoğrafı
Adnan Qidwai3 ay önce

btw the GitHub doesn't seem public yet

Jerry Liu profil fotoğrafı
Jerry Liu3 ay önce

sorry about the above - just made it public!

Ira Rothken profil fotoğrafı
Ira Rothken3 ay önce

This looks very promising for AI legal apps and ESI analysis.

Kevin Madura profil fotoğrafı
Kevin Madura3 ay önce

Have you tested it on OBLIQ-Bench?

Pinkman profil fotoğrafı
Pinkman3 ay önce

hybrid search across the whole index with read, grep, and find is basically giving an agent the same tools a developer would use on a local filesystem

Eugene Yaroslavtsev profil fotoğrafı
Eugene Yaroslavtsev3 ay önce

@jerryjliu0 i haven't been able to find a bug bounty / security program link on gh/llama's official site - got a link?

AW profil fotoğrafı
AW3 ay önce

jerry,dropped you a DM about a paid collab

KYD 玩 ai profil fotoğrafı
KYD 玩 ai3 ay önce

Treating retrieval as a persistent tool surface, with search, grep, file search, and read operations, feels much closer to how agents actually investigate large knowledge bases than one-shot RAG calls.

Dmytro Palaniichuk 🇺🇦 profil fotoğrafı
Dmytro Palaniichuk 🇺🇦2 ay önce

The filesystem metaphor is the right abstraction. Moving from "query the index" to "navigate the knowledge base" made agents far more predictable — they scope reads before writing, like a good engineer. Partial-update primitives, or is re-index always full corpus?

Christian Müller profil fotoğrafı
Christian Müller3 ay önce

Persistent pipeline plus a bounded, filesystem-like tool surface is a strong combo here. The reliability jump comes when each tool call returns a typed result the next step can rely on, not free-form text the agent has to re-parse every run.

srijanarya profil fotoğrafı
srijanarya3 ay önce

The filesystem-style tools were never my bottleneck. Index freshness was. "Index and update a large KB" buries the ugly part: an agent retrieving mid-reindex and answering off a stale chunk. Does the harness guarantee read-during-update consistency?

Sean Kerr — AI, minus the hype profil fotoğrafı
Sean Kerr — AI, minus the hype3 ay önce

The persistent pipeline is the right call. Most "agentic retrieval" pain isn't recall — it's the agent re-indexing the world every run because nothing survives between calls. The harder half: teaching it when it has enough to stop retrieving.

Nahid profil fotoğrafı
Nahid3 ay önce

persistent data pipeline opens up new possibilities

Shashank Nidhi profil fotoğrafı
Shashank Nidhi3 ay önce

Your harness builds a fresh index, but it never flags when a source document drifts. Staleness is a harder problem than retrieval. A vector store can answer a query, yet it has no idea the underlying truth moved two weeks ago. If you attach a provenance check on each update, the agent can decide whether to trust the result.

Nhost profil fotoğrafı
Nhost3 ay önce

The quiet shift here is that retrieval starts looking more like an agent exploring a filesystem: search, grep, read, follow the thread. That's much closer to how people actually research a case

Oleksandr profil fotoğrafı
Oleksandr3 ay önce

agentic retrieval feels like giving an agent a local filesystem watching legal agents actually crawl PDFs is next‑level

Anshuman Singh profil fotoğrafı
Anshuman Singh3 ay önce

The persistent-pipeline framing matches what we hit with travel data: static snapshots rot fast, so continuous dedup plus per-row source tags are what keep agent citations honest. Curious how the harness handles provenance when two indexed sources conflict, do you keep both with lineage or resolve to one?

Jabir | AI Systems profil fotoğrafı
Jabir | AI Systems3 ay önce

👍🏻

Sebastian Buzdugan profil fotoğrafı
Sebastian Buzdugan3 ay önce

index v2 will live or die on permission drift, not tool breadth

Pawzard profil fotoğrafı
Pawzard3 ay önce

agents out here getting a whole filing cabinet meanwhile i still cant find my keys 😭

The Guy With A Hat profil fotoğrafı
The Guy With A Hat3 ay önce

Another OCR. Sweet, is there a paper attached?

egesea profil fotoğrafı
egesea3 ay önce

Retrieval is becoming less about finding information. It's becoming the workspace where agents think and act.

Makaroni profil fotoğrafı
Makaroni3 ay önce

curious how it handles drift tho like the knowledge base updates mid-task and the agent already cached stale context

Brosko profil fotoğrafı
Brosko3 ay önce

ngl 'filesystem operations but for vibes' is actually the unlock agents been fumbling retrieval tasks for too long fr 🔥

Benzer Videolar

Build better RAG by letting a team of agents extract and connect your reference materials into a knowledge graph. Our new short course, “Agentic Knowledge Graph Construction,” taught by Neo4j Innovation Lead Andreas Kollegger, shows you how. Knowledge graphs are an important way to store information accurately but they are a lot of work to build manually. In this course you’ll learn how to build a team of agents that turn data– in this case product reviews and invoices from suppliers–into structured graphs of entities and relationships for RAG. Learn how agents can automatically handle the time-consuming work of building graphs — extracting entities and relationships (e.g., Product "contains" Assembly, Part "supplied_by" Supplier, Customer review "mentions" Product), deduplicating them, fact-checking them, and committing them to a graph database — so your retrieval system can find right information to generate accurate output. For example, you can use agents to help trace customer complaints directly to specific suppliers, manufacturing processes, and product hierarchies, thus turning fragmented information into queryable business intelligence. Skills you’ll gain: - Build, store, and access knowledge graphs using the Neo4j graph database - Build multi-agent systems using Google’s Agent Development Kit (ADK) - Set up a loop of agentic workflows to propose and refine a graph schema through fact-checking - Connect agent-generated graphs of unstructured and structured data into a unified knowledge graph This course gets into the practicum of why knowledge graphs give more accurate information retrieval than vector search alone, especially for high-stakes applications where precision matters more than fuzzy similarity matching. Sign up here:

Andrew Ng

169,184 görüntüleme • 1 yıl önce

Traditional data pipelines don't work for RAG applications. There are 3 issues with them: ​ 1. Traditional data engineering solutions are optimized to handle structured data. RAG applications rely primarily on unstructured data. ​ 2. The connector ecosystem to load data from unstructured data sources is very immature. ​ 3. Traditional solutions do not offer any way to transform unstructured data into an optimized vector search index. ​ The goal of a RAG Pipeline is to solve these problems. ​ The number one objective is to create a reliable vector search index using factual knowledge and relevant context. This sounds easy, but it's one of the biggest challenges we face when building RAG applications. ​ At a high level, there are four different stages in the architecture of a RAG pipeline: ​ 1. Ingestion: Here is where the pipeline loads the information from the data source. ​ 2. Extraction: Where the pipeline processes the input data and decides how to retrieve the text contained inside them. ​ 3. Transform: Where the pipeline chunks the data and generates document embeddings. ​ 4. Load: Where the pipeline creates a search index in a vector database and loads the document embeddings. ​ There are different rabbit holes at each one of these stages. Here are three of them: ​ 1. Ingesting data once is simple. The hard part is refreshing the vector database whenever the original data source changes. ​ 2. Extracting the content of a plain text document is simple. The hard part is to extract content from complex documents containing tables, images, or cross-references. ​ 3. A simple continual chunking strategy with an overlap is simple. The hard part is to find the optimal strategy for your specific knowledge base and the way you are planning to query it. ​ In the attached video, I'll show you how you can build an enterprise-grade RAG Pipeline that solves every one of the above problems. ​ I'll use Vectorize. They partnered with me on this post. You can use them to build RAG pipelines optimized for accurate context retrieval. ​ ​ If you have a few documents lying around, set up a free account and give it a try.

Santiago

40,643 görüntüleme • 2 yıl önce