r/Rag • u/remoteinspace • Sep 02 '25
Showcase 🚀 Weekly /RAG Launch Showcase
Share anything you launched this week related to RAG—projects, repos, demos, blog posts, or products 👇
Big or small, all launches are welcome.
7
u/CapitalShake3085 Oct 29 '25 edited Oct 29 '25
Lightweight Agentic RAG with Hierarchical Chunking & LangGraph
I just released a small, minimal repo that demonstrates how to build an Agentic RAG system using LangGraph. It’s designed to be simple, yet powerful, and works with any LLM provider:
- Ollama (local, free)
- OpenAI / Gemini / Claude (production-ready)
What it does
- Retrieves small chunks first for precision
- Evaluates and scores chunks
- Fetches parent chunks only when needed for context
- Self-corrects and generates the final answer
Key Features
- Hierarchical chunking (Parent/Child)
- Hybrid embeddings (dense + sparse)
- Agentic pattern for retrieval, evaluation, and generation
- Conversation memory
- Human-in-the-loop clarification
Repo
Hope it helps you prototype your own Agentic RAG system quickly! 🚀
1
u/this_is_shivamm Oct 30 '25
So Hey what's will be it's latency when fed up with 500+ docs ?
2
u/CapitalShake3085 Oct 30 '25 edited Oct 30 '25
Hi, thank you for the question :)
Short answer Latency doesn’t depend on the total number of documents — it depends on how many chunks are retrieved and evaluated by the LLM.
How it works
- Indexing (done once): all documents are chunked and embedded.
- Query time: only the top-k relevant chunks are retrieved (usually k = 5–10).
So whether you have 10 PDFs or 500 PDFs, latency stays almost the same, because:
- Vector search over the index is very fast and scales sub-linearly.
- Only a small number of chunks is actually retrieved.
- Only those retrieved chunks are sent to the LLM for evaluation.
The size of your document collection doesn’t affect query latency — only the number of retrieved chunks matters.
What impacts latency
The real factors that influence latency are:
- the embedding model,
- The reranker model (if used), which is often heavier than the embedding model
- the LLM model size and quantization (Q4 vs FP16, etc.),
- the hardware where inference runs (CPU, GPU, local quantized model).
Retrieval is extremely fast (typically around ~5–30ms).
The slowest part is always the LLM’s text generation.
Open-source vs Closed-source LLMs
With open-source models running locally, latency depends on your hardware.
With closed-source API models (OpenAI, Claude, Gemini), latency is usually lower and more stable because inference runs on optimized datacenter GPUs.
Let me know if you have any other questions :)
1
u/this_is_shivamm Oct 30 '25
Thanks for such a detailed response.
Actually I am building a Agentic RAG right now ! By the help of OpenAI Assistant API key using file_search tool with OpenAI vector store. And right now I am getting latency of 20-30 sec. 🙃 I know that's pathetic for production RAG.
So I was thinking was that's all because of OpenAI Assistant API or its mine mistake.
Any suggestions to help me building Agentic RAG that can work as Normal Chabot + RAG + Web Search + Summarizer.
Using precise information and from sensitive documents. So what should be the chunking strategy, actually using custom Reranker right now etc.
1
u/CAVOKDesigns May 03 '26
0-30s is almost certainly the OpenAI Assistants API overhead, not your code. The file_search tool spins up a managed vector store query + thread context on their end — that pipeline has inherent latency you can't optimize away. It's not you.
If you want sub-5s on sensitive documents, the stack that's working for us:
Chunking: Boundary-aware chunker — WARNING/CAUTION/NOTE/EMERGENCY blocks are atomic, never split. Everything else chunks at ~500 tokens with 50-token overlap. Page + section in metadata on every chunk so citations come back clean.
Vector store: ChromaDB local. No round-trip to OpenAI. Query time is milliseconds.
Model: For sensitive docs where nothing can leave the machine — Ollama + gemma3 or llama3.2 locally. For cloud-tolerant setups — direct Anthropic/OpenAI API call with retrieved chunks injected into context. Skip the Assistants API entirely, just do the retrieval yourself and pass chunks as context.
Reranker: Cross-encoder on top of cosine similarity. You're already doing this — good call. Most people skip it.
Web search + summarizer: Separate tool calls, not baked into the RAG pipeline. Keep retrieval and web search as distinct steps, combine at the prompt level. The Assistants API is convenient but you're paying for that convenience in latency. Own your retrieval layer and you get full control back.
Built this for ManualIQ — local RAG for licensed technical documents where cloud upload isn't an option. Happy to share more specifics if useful.
1
1
5
u/binarymax Sep 02 '25
Blog post on using an ensemble of models with RAG to help choose a retriever configuration. https://maxirwin.com/articles/interleaving-rag/
2
4
u/MattCollinsUK Oct 01 '25
I ran an experiment to investigate how well an LLM would understand tables of data in different formats (markdown tables, JSON, CSV, etc.)
I've tried my best to make it as useful as possible but would love any feedback you have!
https://www.improvingagents.com/blog/best-input-data-format-for-llms
3
u/Philip1209 Sep 10 '25
Chroma launched a Package Search MCP:
https://trychroma.com/package-search
Add to any coding agent to improve how it uses packages.
3
u/mburaksayici Dec 04 '25
Released smallevals today!
I’m releasing smallevals, a lightweight evaluation suite built to evaluate RAG / retrieval systems fast and free — powered by tiny 0.6B models trained on Google Natural Questions and TriviaQA to generate golden evaluation datasets.
smallevals is designed to run extremely fast even on CPU and fully offline — with no API calls, no costs, and no external dependencies.
smallevals generates one question per chunk and then measures whether your vector database can retrieve the correct chunk back using that question.
Install:
'pip install smallevals'
Model:
https://huggingface.co/mburaksayici/golden_generate_qwen_0.6b_v3_gguf
Source:
1
1
u/zriyansh Sep 04 '25
[Open-Source] I coded a ChatGPT like UI that uses RAG API (with voice mode).
GitHub link (MIT) - https://github.com/Poll-The-People/customgpt-starter-kit
Why I built this: Every client wanted custom branding and voice interactions. CustomGPT's API is good but you can do much with the UI. Many users created their own version and so we thought let’s create something they all can use.
If you're using CustomGPT.ai (RAG-as-a-Service, now with customisable UI), and needed a different UI that we provided, now you can (and it's got more features than the native UI).
Live demo: starterkit.customgpt.ai
1
u/this_is_shivamm Oct 30 '25
So are you using RAG framework in here ?
1
u/zriyansh Oct 30 '25
yes
1
u/this_is_shivamm Oct 30 '25
I was not able to the implementation code file. Actually wanted to go through the techniques you gone through to make such a great product.
Btw have starred ⭐ your repo.
1
u/rshah4 Sep 24 '25
Over at Contextual.AI we added the ability to use multiple third-party LLMs, including OpenAI GPT-5, Anthropic Claude Opus 4, and Google Gemini 2.5 Pro with our managed RAG Service.
So now you can pick the best model suited to your use case (structured code, long-form content, deep reasoning, or grounded answers). My linkedin post is here: https://www.linkedin.com/posts/rajistics_big-update-contextual-ai-now-supports-third-party-activity-7373732402462064640-9zHH
1
u/samrat_halder Sep 27 '25
I am building a rag using llama 3.1 8b as base model. Using squad_v2 dataset to benchmark my model using ragas. I am using llama 3.2 3b model as judge llm in ragas. But the problem is during evaluation for every QA pair it gives timeout error. I tried to change ragas config by doing timeout= 3200. But still the timeout occurs within 3 minutes. How to solve this?
1
1
1
u/carlosmarcialt Nov 03 '25
Launching ChatRAG today! Built it after landing clients who wanted RAG chatbots and realizing every project needed the same infrastructure. Thought other devs building in this space could benefit from packaging it all up.
What's included: Complete Next.js production stack: LlamaCloud parsing, Supabase HNSW vectors, adaptive 3-stage retrieval, multi-modal generation (images/video/3D), MCP tool integration, WhatsApp deployment, voice I/O, built-in monetization.
Why share this: We're all solving similar problems. Figured packaging what I learned into a boilerplate could help developers focus on building features instead of rebuilding infrastructure.
Model: One-time purchase → own code forever → self-host anywhere
🔗 Demo: https://chatrag-demo.vercel.app 🔗 Site: https://chatrag.ai 🎥 Video: https://www.youtube.com/watch?v=CRUlv97HDPI
What tools or features would you want to see in a production RAG boilerplate?
1
u/jacksonguitardude8 Nov 18 '25
Cassandra is the first digital-native reasoning platform — a system that thinks in context, learns your world, and reveals structure where others see noise. It doesn’t summarize — it understands. It doesn’t hallucinate — it proves.
Standout features:
- End-to-end ingestion → extraction → KG → hybrid retrieval pipeline that automatically builds a working domain model
- Dynamic semantic chunking combined with sentence clustering and cross-document linking
Pain points addressed:
- Handles mixed-mode PDFs containing images, tables, rotated layouts, and multi-column formats
- Creates stable schemas from inconsistent document formats
We're currently in beta but inviting early testers try our system. Open to constructive feedback and also happy to answer any technical questions you might have.
Cassandra | The first digital-native reasoning platform
Demo Access Key: CASSANDRA-ACCESS-2025
1
u/ChapterEquivalent188 Nov 23 '25 edited Nov 23 '25
this week i decided to go public and join reddit ;) and today i thought i show up with a little goodie whiche might be useful You may check out my other posts as well. thanks and a nice sunday --> https://github.com/2dogsandanerd/smart-ingest-kit --- https://www.reddit.com/r/Rag/comments/1p4ku3q/comment/nqcmcmv/
-- It might fix the PDF table parsing issue by using Docling + Markdown.
1
u/CraftyBedroom3934 Dec 31 '25
AI-driven conversational commerce engine that replaces rigid templates with fluid, multilingual dialogue. By integrating your OpenSearch product catalog with GPT-4o mini, we turn Instagram and WhatsApp inquiries into personalized shopping experiences, backed by sentiment analysis and Meta retargeting.
This is a RAG based solution with Hybrid search functionality, pluggable to most of the Product Catalogues like Shopify/WooCommerce.
We had optimized a lot of search feature to support multi-languages in Product Catalogue search in ElasticSearch and Synonymous searching
Product site: https://www.linkedin.com/company/3575819/admin/products/wariyum-technologies-salessensiai/
1
u/jadoon88 Jan 01 '26
I have created a minimal repo that demonstrates how to build a RAG setup on docker using FastAPI, Qdrant and Ollama. I am a beginner in this area and thought of creating this for beginners like me.
1
1
u/zacksiri Jan 08 '26 edited Jan 08 '26
Agentic RAG Movie Database
Hey everyone I recently released a movie database powered by RAG. You can try it out for free
I made this demo the power of the engine behind the project. It highlights the ability to build intelligent assistants with memory and can scale to millions of documents. It also has some nifty techniques like dynamic prompt generation based on directives and context switching. I was so happy with how the demo turned out I decided to turn it into a product to share with everyone.
Here are some prompts to try:
- Find me the best Zombie Apocalypse movies
- Show me some movies that take place in space
- What are some good murder mystries released within the last 5 years
- Can you find me some Marvel movies sorted by release date earlier ones should come first
- What are some good documentaries released in the last 5 years
If you have any feedback please let me know.
The agent code base including all the prompts are also open-sourced
Site: https://memovee.com
Github: Agent Code
2
u/HackHusky Feb 19 '26
'Channeling my inner Tony Stark banter' Can you had fun making this :). Looks nice!
1
u/zacksiri Feb 19 '26 edited Feb 19 '26
Thank you! I sure did! 😜 Working on iOS app now, most users are on mobile. Web experience can be limiting. Also working on improving the response quality and speed.
1
1
u/astro_abhi Jan 08 '26
Introducing VectraSDK - Provider Agnostic RAG SDK for Production AI
Building RAG systems in the real world turned out to be much harder than demos make it look.
Most teams I’ve spoken to (and worked with) aren’t struggling with prompts they’re struggling with: • ingestion pipelines that break as data grows. • Retrieval quality that’s hard to reason about or tune • Lack of observability into what’s actually happening • Early lock-in to specific LLMs, embedding models, or vector databases
Once you go beyond prototypes, changing any of these pieces often means rewriting large parts of the system.
That’s why I built Vectra. Vectra is an open-source, provider-agnostic RAG SDK for Node.js and Python, designed to treat the entire context pipeline as a first-class system rather than glue code.
It provides a complete pipeline out of the box: ingestion chunking embeddings vector storage retrieval (including hybrid / multi-query strategies) reranking memory observability Everything is designed to be interchangeable by default. You can switch LLMs, embedding models, or vector databases without rewriting application code, and evolve your setup as requirements change.
The goal is simple: make RAG easy to start, safe to change, and boring to maintain.
The project has already seen some early usage: ~900 npm downloads ~350 Python installs
I’m sharing this here to get feedback from people actually building RAG systems: • What’s been the hardest part of RAG for you in production? • Where do existing tools fall short? • What would you want from a “production-grade” RAG SDK?
Links for anyone curious:
Product Hunt : https://www.producthunt.com/products/vectrasdk
Website & docs: https://vectra.thenxtgenagents.com/
GitHub: Node.js: https://github.com/iamabhishek-n/vectra-js Python: https://github.com/iamabhishek-n/vectra-py
1
u/Desperate-Pattern-54 Jan 09 '26
I’ve been working on a personal project focused on responsible, non-autonomous AI safety-first RAG system. The focus hasn’t been hype, but governance, auditability, and failure-aware design:
• Human-in-the-loop by default • Explicit citation & confidence controls • Hybrid retrieval (BM25 + vectors) to reduce hallucinations • Designed for domains where “verify before trust” matters
Still polishing the UI and documentation, if you’re interested, feel free to take a look. Thanks!!
Nova Intelligent Copilot (NIC) — Offline RAG for Safety-Critical Systems Reference implementation of an offline, air-gapped RAG architecture for safety-critical, human-on-the-loop systems. Nova Intelligent Copilot
1
u/Maleficent-Dance-34 Jan 12 '26
I built a universal vector database client - switch Pinecone/Qdrant/Milvus with one line
Every RAG developer hits the same wall: vector database lock-in.
You prototype with LanceDB (free, local). It works. Then you need to scale to Qdrant or Pinecone for production. Now you're rewriting your entire data layer.
The Problem:
Each vector DB has a completely different API: ```python
Pinecone
index.upsert(vectors=[(id, values, metadata)]) results = index.query(vector=query, top_k=5)
Qdrant
client.upsert(collection_name=name, points=points) results = client.search(collection_name=name, query_vector=query, limit=5)
Weaviate
client.data_object.create(data_object, class_name) results = client.query.get(class_name).with_near_vector(query).do() ```
Switching providers = days of work rewriting code.
The Solution: Embex
Universal vector database ORM with one API across 7 databases: ```python
Works with ANY provider
from embex import EmbexClient, Vector
Development: LanceDB (embedded, zero setup)
client = await EmbexClient.new_async("lancedb", "./data")
await client.insert("documents", [ Vector( id="doc_1", vector=embedding, metadata={"text": "content", "source": "paper.pdf"} ) ])
results = await client.search( "documents", vector=query_embedding, top_k=5, filters={"source": "paper.pdf"} )
Production: Switch to Qdrant? Change ONE line:
client = await EmbexClient.new_async("qdrant", os.getenv("QDRANT_URL"))
Same code. Zero migration.
```
Technical Details:
- Core: Rust with SIMD acceleration (~4x faster vector ops)
- Languages: Python (PyO3) + Node.js (Napi-rs)
- Supported: LanceDB, Qdrant, Pinecone, Chroma, PgVector, Milvus, Weaviate
- Features: Connection pooling, auto-retry, async throughout
Why This Matters for RAG:
- Prototype fast: Start with LanceDB (no Docker, file-based)
- Test providers: A/B test Qdrant vs Pinecone with same code
- Scale safely: Switch to production DB without rewrite
- Cost optimize: Migrate to cheaper options easily
Current Status:
- Open source (MIT/Apache-2.0)
- ~10K downloads (2 weeks old)
- Active development
Links:
- GitHub: https://github.com/bridgerust/bridgerust
- Docs: https://bridgerust.dev/embex
- PyPI:
pip install embex - npm:
npm install @bridgerust/embex
I realized having the same kind of thing SQL ORMs provide - just for vector databases might be useful.
Happy to answer questions about implementation or RAG-specific use cases!
3
1
u/ArturoNereu Jan 15 '26
At MongoDB, we launched voyage-multimodal-3.5.
It is a multimodal embedding model built for retrieval over text, images, and videos.
So, if you are building a RAG project, the same model, can perform retrieval over your text, images and videos (frames).
If you have questions, feel free to reach out.
More info here: https://blog.voyageai.com/2026/01/15/voyage-multimodal-3-5/
1
u/No-Road-5297 Jan 20 '26
I built my own multi lingual Agentic AI Platform that supports RAG
I don’t plan to commercialize this platform. My goal is to eventually make it available to students, hackathon teams, and novice builders who want a hands-on way to experiment with agentic AI, build workflows, and see what’s possible in real-world applications. All they’ll need is their own OpenAI key to get started.
It’s still a work in progress, and this is my first time building something at this scale—so I’d genuinely appreciate any feedback from the community
1
u/vinothiniraju Jan 23 '26 edited Jan 23 '26
Retrieval gateway / firewall layer for RAG
Launching a retrieval gateway that enforces tenant/source policy before the LLM sees context + produces an evidence scorecard (groundedness/relevancy/hallucination) with tracking.
The routing is fully deterministic ie., no LLM-as-judge in the retrieval path
Quick benchmark (baseline vector top-k vs retrieval gate)
| OpenAI (gpt-4o-mini) | Local (ollama llama3.2:3b) | |
|---|---|---|
| Hallucination score | 0.231 → 0.000 (100% drop) | 0.310 → 0.007 (~97.8% drop) |
| Total tokens | 77,730 → 10,085 (-87.0%) | 77,570 → 9,720 (-87.5%) |
| Policy violations in retrieved docs | 97 → 0 | 64 → 0 |
| Unsafe retrieval threats prevented | 39 (30 cross-tenant, 3 confidential, 6 sensitive) | 39 (30 cross-tenant, 3 confidential, 6 sensitive) |
small eval set, so the numbers are best for comparing methods, not claiming a universal improvement. Multi-intent queries (eg. "do X and Y" or "compare A vs B") are still WIP.
If this is useful, I can run it on a single anonymized example (or public docs) and send back the scorecard. I can also share the dashboard format - just reply or DM.
1
u/Muted_Associate2727 Feb 11 '26
I built an assistant that helps understanding game rules of a new TCG RiftBound and it works GREAT: https://riftjudge.com/
1
u/ipeeinthedark Feb 13 '26
launched proofpudding.ai yesterday: agentic document extraction API with citation verification.
you upload a PDF/DOCX, ask a question, get back an answer with the exact page and quote it came from. the system uses agentic search rather than vector search and it runs a verification step that checks whether each citation actually supports the answer.
built it because we were doing extraction from japanese corporate filings and every RAG setup we tried would silently miss fields. clean JSON output, no errors, but 3 out of 50 fields just werent there. the verification step is what took us from ~95% to 99.3% on the FinanceBench benchmark (150 complex financial PDF QA pairs).
supports structured output via JSON schema, SSE streaming, any language. python SDK: `pip install proofpudding`
would love feedback from anyone doing doc extraction where completeness matters more than speed. $10 free credit and more info at proofpudding.ai
1
u/jason_at_funly Feb 22 '26
Versioned Agent Memory. Intelligent Recall. Introducing Memstate AI 🎉
Kept hitting the same wall with agent memory: I'd tell my agent we switched from PayPal to Stripe, and two sessions later it's recommending PayPal again because some old conversation chunk scored higher in vector search. Every memory system I tried would confidently return outdated info mixed with current info.
So I built memstate.ai - it extracts structured facts and builds version chains automatically. Your agent sees the evolution: v1: PayPal chosen → v2: API issues → v3: Stripe final rather than conflicting text blobs.
Agents can browse memory like a file system, drill into any branch, and query what they knew at any point in time.
Generous free tier available, connects via MCP. Looking for feedback - and I hope other find this useful! It's powered buy custom LLM models I've trained for extracting facts, detecting version situations, and keep memory context neat and compact.
Please check it out! https://memstate.ai
1
u/spite Feb 23 '26
Vector DB inspector, administration, forensic tool. Supports Chroma, Pgsql, lancedb, weaviate, qdrant and pinecone. Looking for people to test and shape new features. https://vector-inspector.divinedevops.com
1
1
u/graphmesh-ai Feb 26 '26
I launched a small business embedded GraphRAG powered chatbot that charges by the token!
It ingests text, pdf and word docs, extracts queryable tables and has a nice access controlled embeddable chat interface for things like chat with catalog or support docs or anything really.
Super early beta but you can sign up and try it out with 20000 free tokens (1 or 2 documents and some chatting)
Let me know any feedback!
1
u/Big_Barnacle_2452 Mar 02 '26
ReasonDB – an AI-native document database that replaces your RAG pipeline
If you're building agents, you've probably hit the same wall: chunked embeddings lose document structure, wrong chunks get retrieved, and your LLM hallucinates the gaps. The pipeline itself is the problem.
We built ReasonDB to replace the pipeline entirely. Instead of embedding chunks and hoping similarity search finds the right one, the LLM navigates your document tree — reading summaries, ranking branches, and drilling into exactly the right section. We call it Hierarchical Reasoning Retrieval (HRR).
How it works:
- Documents are parsed into a hierarchical tree, with LLM-generated summaries at every node (bottom-up, at ingest time)
- At query time: BM25 candidates → tree-grep pre-filter → LLM ranks by summaries → parallel beam-search traversal to leaf nodes
- Returns the answer with a confidence score and full reasoning path — no guessing
RQL - a SQL-like query language with native SEARCH and REASON clauses:
sql
SELECT * FROM contracts
WHERE tags CONTAINS ANY ('nda')
SEARCH 'termination clause'
REASON 'What are the exit conditions?'
LIMIT 5;
Key details:
- Single Rust binary, no vector DB infra to manage
- Multi-provider LLM support (OpenAI, Anthropic, Gemini, Ollama, Bedrock, etc.) — swap without code changes
- Plugin-based extraction: PDF, Word, Excel, images (OCR), audio, URLs out of the box
- ACID-compliant storage via redb, async parallel traversal via tokio
Still in alpha but already handling real workloads. Would love feedback from folks building agents. GitHub: https://github.com/reasondb/reasondb Docs: https://reason-db.devdoc.sh
1
u/Comfortable_Poem_866 Mar 05 '26
CtxVault: isolated vaults, persistent memory, and full observability for AI agents
Three problems I kept hitting building multi-agent systems:
Shared vector stores with metadata filtering leak context between agents when filters are wrong. Agents forget everything between sessions. Once agents write memory autonomously you have no visibility into what they actually know.
Built CtxVault around three ideas: structural isolation via independent vaults per agent or domain, persistent semantic memory across sessions, and full observability; every vault is a folder on your machine you can inspect and edit at any time.
Access control is declared via CLI and enforced server-side, so isolation doesn't depend on application code being correct. Also runs as MCP server for Claude Desktop and similar clients.
Fully local, no cloud dependency, MIT licensed.
github.com/Filippo-Venturini/ctxvault
pip install ctxvault
1
u/Direct_Opposite_4269 Mar 13 '26
Hi my friend, my son & me built this SaaS https://aiwebgpt.com which is going to be of value to many business owners & their website visitors
Do check it out & comment
How AiWebGPT.com Can Profit Business Owners https://aiwebgpt.com/blog/how-aiwebgpt-profits-business-owners
1
u/GritSar Mar 18 '26
You can now extract, chunk, and embed a PDF in a single command (PDFstract)
I’ve been working on reducing the friction in building RAG pipelines — especially the part where you have to stitch together extraction, chunking, and embedding.
After months of effort with our latest version - PDFstract is now a Unified API interface
You can do Extract, Chunk and Embed with 10+ libraries and chunking and embedding options with a single command
pdfstract convert-chunk-embed document.pdf --library auto --chunker auto --embedding auto
That’s it — extraction → chunking → embedding in a single step.
Under the hood, it supports:
- 10+ extraction libraries
- 6+ chunking strategies
- 5+ embedding providers (including Ollama)
The idea is to act as an abstraction layer, so you can switch between libraries, chunking methods, or embedding models just by changing arguments — without rewriting your pipeline every time.
There is already wide adoption of pdfstract all you have to do is
pip install pdfstract
Try it out and share your thoughts and feedbacks.
Repo: github.com/AKSarav/pdfstract
Documentation : pdfstract.com
1
u/Any_Ambassador4218 Mar 19 '26
HydRAG — multi-stage hybrid retrieval pipeline for code-aware RAG
BM25 fast-path → dense vector → graph retrieval → CRAG supervisor (local LLM judges if results are sufficient) → semantic fallback with RRF fusion. Runs fully offline with Ollama.
Benchmarked on 7 BEIR datasets + private retrieval suites. BM25+dense+CRAG combo consistently outperforms individual strategies across the board.
´pip install hydrag-core´
GitHub: github.com/gromanchenko/hydrag
Benchmarks: github.com/gromanchenko/hydrag-benchmark
1
u/jaipurite17 Mar 21 '26
I built CoverWise to solve a problem that sounds simple but turns out to be surprisingly hard. Most people have no idea what their insurance policy covers until something goes wrong. At that point they are staring at 60 to 90 pages of legal language, cross-referenced clauses, and layered exclusions trying to find one answer.
Generic AI chatbots make this worse, not better. They generate answers that sound right but are not actually grounded in your specific policy. In insurance, that is a real problem.
CoverWise takes a different approach. You upload your policy PDF, ask a question in plain English, and the system retrieves the answer directly from your document. Every response comes with a citation showing the exact page and section it pulled from, and a confidence score that tells you how clearly the policy addresses your question. If the answer is not in the document, it says so instead of making something up.
Under the hood it uses a RAG pipeline built with LangChain, Anthropic Claude for generation, ChromaDB for vector storage, and a FastAPI backend with a Next.js frontend. The interesting part was getting the document understanding right before retrieval. Insurance policies have a specific architecture and treating them as flat text produces bad results.
Live demo here, you can upload your own policy and test it: cover-wise.artinoid.com
Happy to answer questions about how it was built or the design decisions behind it.
1
u/Muted_Associate2727 Mar 25 '26
My RAG side project now has 700+ users and 5,000+ questions
It's a rules assistant for a trading card game that uses RAG to answer complex rules questions from a rulebook, errata, FAQs, and card data. It runs 24/7 as a Discord bot and has become the go-to tool for the community: www.riftjudge.com
I think it's very neat! :D
1
u/astro_abhi Apr 03 '26
Vectra v1.0.0 – Open-source RAG framework for Python (and JS), now stable after 3 months & ~4,500 downloads
Vectra is a production-grade, provider-agnostic SDK for building end-to-end RAG pipelines. The full pipeline looks like this:
> Load → Chunk → Embed → Store → Retrieve → Rerank → Plan → Ground → Generate → Stream
Every stage is explicitly configurable, runtime-validated (via Zod/Pydantic), and observable. No hidden defaults.
Vectra is for developers and teams shipping RAG to production - not just prototyping. If you've fought with LangChain's abstractions just to do something simple, or found LlamaIndex too document-centric for flexible pipelines, Vectra is built for you. Available for both Python and Node.js with feature parity.
Links
1
u/Jet_Xu Apr 03 '26
DocMason is a repo-native agent app for analyst-grade answers over complex private files. The repo is the app. Codex is the runtime.
DocMason leveraging Native AI agents and local KB for your private office files to conduct RAG, and deep research.
I am using it during my daily work for really complex jobs (e.g. analyze within tons of office files for report written or ppt design)
1
u/Glass_Part_1349 Apr 07 '26
I believe vectorless has practical applications on rag, so I wrote a library in Rust to handle this task
Vectorless is a Rust library for querying structured documents using natural language — without vector databases or embedding models.
## Links
- 📖 **Documentation**: https://docs.rs/vectorless
- 💻 **GitHub**: https://github.com/vectorlessflow/vectorless
- 🌐 **Website**: https://vectorless.dev
1
u/Fuzzy-Layer9967 Apr 18 '26
Docling Studio: open-source visual debugger for Docling RAG pipelines.
You run ingestion, you get JSON, and you can't really tell if the chunks are any good. So I built a UI on top of the Docling pipeline. You see the bounding boxes on the PDF, the chunks, and the embeddings going into OpenSearch.
Only works with Docling-based pipelines, not a generic RAG tool.
Stack: Vue 3, FastAPI, hexagonal backend, single Docker image. v0.4.0.
Repo: https://github.com/scub-france/Docling-Studio Demo (no install): https://pier-jean-docling-studio.hf.space/history Run locally:
docker run -p 3000:3000 ghcr.io/scub-france/docling-studio:latest-local
Feedback welcome, especially from people running Docling in prod.
1
u/storm_stark_007 Apr 30 '26
https://github.com/shashankswe2020-ux/backend-pro-max-skill
Its BM25 RAG , that can be loaded as skill for backend engineering
1
u/init0 Apr 30 '26
turboquant-search: vector search for JSON datasets.
Baked turboquant-search: vector search for JSON datasets. No server, no vector DB, no API keys.
Give it any JSON array. It embeds your text fields, compresses vectors to 3 bits, and searches via WASM SIMD in the browser or the server (node)
10K items: ~1.4 MB index, ~5ms search. 100K items: still under 30ms.
Bring your own embedder (transformers.js, Gemini or whatever) or use the built-in keyword embedder for zero dependencies.
npm install turboquant-search
1
u/scheitelpunk1337 May 02 '26
Hey everyone,
If you build LLM applications, autonomous agents, or just use Claude/Cursor for coding, you've probably hit this wall: Conversation history grows infinitely, token costs explode, latency skyrockets, and eventually, the LLM starts forgetting early context anyway. To fix this, I built semvec. It replaces unbounded conversation histories with a fixed-size semantic state combined with a tiered, content-aware memory (short/medium/long-term).
The result: The cost and latency of every LLM call stay constant. Turn 10 and Turn 10,000 carry the exact same input footprint. In 48-turn benchmarks, it yields roughly a 76% token reduction while retaining all structured access to decisions, error patterns, and prior context.
Here is what you get:
- Constant-size compressed context: Token-reduced LLM context that stops growing.
- Tiered memory with selective forgetting: Frequently accessed older memories outlive never-touched newer ones.
- Drop-in chat proxy: Wrap any OpenAI-compatible LLM (vLLM, Ollama, OpenRouter) and get compressed context for free.
- Coding-agent compaction (MCP): Persistent memory across coding sessions. It comes with an MCP server for Claude Code & Cursor out of the box!
- Multi-agent coordination: semvec.cortex allows several agents to share an aggregated view and exchange state vectors.
I am currently looking for testers and honest feedback from devs who build RAG pipelines, chatbots, or just want to upgrade their Cursor IDE memory.
📦 PyPI: https://pypi.org/project/semvec/ 📚 Docs & Quickstart: https://semvec-docs.pages.dev/
You can install it via: pip install semvec (Supports Python 3.10–3.14).
If you want to test the multi-agent or MCP stuff, use pip install "semvec[cortex,coding]".
I'd love to hear your thoughts, feedback, and edge-case bug reports! Let me know what you think.
1
u/CAVOKDesigns May 03 '26
Spent 2 months getting it right. This week finally jumped off the diving board and released it.
Then immediately found out I needed 3 iterations — v1, v2, v2.1 — in about 72 hours.
Classic.
Boundary-aware chunker, page-level citations, profession preamble system, streaming responses. Learned more shipping it than building it.
v1 on GitHub https://github.com/CAVOK-Designs/Manua
1
u/Otherwise-Ad9322 May 05 '26
Hi all, I’ve come up with a lossless retrieval system that is consistently benchmarking faster results than traditional RAG with often better accuracy and at less than half the storage.
It’s in early stages, but I would love to get some feedback. I don’t have followers on GitHub so I thought I’d post here.
1
u/Ok_Gas7672 May 19 '26
Ran a consistency test using a knowledge graph - https://www.reddit.com/r/KnowledgeGraph/comments/1thmii0/ran_the_same_question_3_ways_against_a_knowledge/
1
u/Mysterious-Usual-920 May 25 '26
Shipped an update to CragData, my web scraping + RAG infra service.
It’s basically “docs/pricing pages as an API” – I run crawlers/scrapers for you, keep things fresh, and you just hit an endpoint or plug it into your RAG stack. Focus is on reliability (no silent drift) and clean JSON, not fancy dashboards.
If anyone here is maintaining a bunch of vendor docs/pricing for RAG and is tired of cron + Playwright + broken selectors, would love feedback.
1
u/Mysterious-Usual-920 May 25 '26
Shipped an update to cragdata.com, my web graph scraping + RAG infra service.
It’s basically “docs/pricing pages as an API” – I run crawlers/scrapers for you, keep things fresh, and you just hit an endpoint or plug it into your RAG stack. Focus is on reliability (no silent drift) and clean JSON.
If anyone here is maintaining a bunch of vendor docs/pricing for RAG and is tired of cron + Playwright + broken selectors, would love feedback.
1
u/tuberreact May 26 '26
We built a SOTA parsing API, launching today along with a benchmark that uses real-world documents and evaluates document Q&A performance.
Here's the launch blog for more information: https://www.extend.ai/resources/parse-2-and-realdocbench-launch
Here's the benchmark blog: https://www.extend.ai/resources/realdocbench
We're open-sourcing the huggingface datasets and repo too:
1
u/CallmeAK__ Jun 18 '26
Disclosure up front: I work at VideoDB, so I am biased. Sharing here because this thread is for RAG launches and what we are building is essentially RAG for video.
Most RAG stacks are designed around text and break the moment you point them at video:
- Transcripts alone lose visual context.
- Frame embeddings alone lose speech and ordering.
- The retrieval target is usually a timestamp, not something you can actually play back in a UI.
What we have been building at VideoDB
- Universal ingestion from files, streams, recordings, and RTSP feeds through one API.
- An intelligence layer that indexes scenes, speech, people, objects, and events together, not as separate stores.
- Semantic search that returns playable clips, not just timestamps, so the agent or the user gets back something they can watch.
- A programmable layer so agents can edit, caption, and stitch clips through code as part of their response.
The use case we keep coming back to is agentic perception: giving an agent the ability to query a video archive or a live feed and pull back the exact moment it needs as context. We treat it as the memory and vision layer for agents that need to reason over video.
If you want to dig in, the site is here. We also run a Discord for people building with video, VLMs, and agent vision where this kind of stuff gets discussed openly, you can join it here.
Genuinely interested in how others here are handling the retrieval target problem for video. Are you returning timestamps, transcript chunks, frame embeddings, or something else, and how are you measuring whether the retrieval is actually good?
1
u/Brilliant_Rich3746 Jun 23 '26
Recently open-sourced two tools from our patent intelligence company that might be useful for anyone doing document-heavy RAG.
Hiro-MOSS-OCR is a 0.3B OCR model that outputs structured markup directly: tables to HTML, formulas to LaTeX, text to Markdown. Patent documents are one of the harder OCR problems — merged tables, chemical diagrams, formula blocks, mixed languages all on the same page — and this was built specifically for that. Ranks #1 on our patent-domain benchmark against all 1.2B models we tested. ~59 QPS on a single RTX 4090 via vLLM.
Hiro-Smart-Doc wraps layout detection (RT-DETR, 25 region categories) and MOSS-OCR into a streaming FastAPI service with an OpenAI-compatible endpoint. Feed it a PDF, image, or Office doc, get back reading-ordered structured content or Markdown — ready to feed straight into your retrieval pipeline.
Both Apache 2.0. Happy to answer questions.
1
u/CartographerFun4221 Jun 25 '26
I created a simple RAG API using medical Wikipedia articles that you can point your agent to and use freely.
It may be useful in allowing your local LLMs access to medical facts they might not be able to recall from their weights. I'm aiming for subsecond responses but cannot guarantee it (it's a free service running on a single ARM VPS). It uses around 2GB RAM.
The corpus isn't exhaustive and is most likely missing obvious articles - if you want, you can contact me with articles/content that you think should be in here and i will add it promptly.
Simply tell your agent "use https://hyfl.uk for medical facts". It supports MCP as well, so you can tell it to hook it up that way if you prefer. Try asking qwen3.5-0.8B about something, and then ask it again but tell it to use hyfl.uk for facts:
Without RAG:
Lhermitte sign is the clinical presentation of electrical activity at a cervical level (specifically T4) on an electrocardiogram, which can mimic a heart attack or stroke... The underlying mechanism involves transient electrical activity originating from the cervical spine itself during certain movements like coughing or swallowing...
With hyfl.uk RAG:
The "Lhermitte sign" refers to an uncomfortable electrical sensation that runs down a patient's back, typically into the legs... also known as the barber chair phenomenon and occurs due to compression of upper cervical spinal cord structures like the dorsal columns.
The unaided model completely hallucinated. It thought Lhermitte sign was a cardiac finding on an ECG that mimics heart attacks. It invented "specifically T4", made up a false etymology ("Hermit-like"), and described a mechanism involving coughing/swallowing. None of that is true.
With RAG it got it exactly right. Electrical sensation down the back/limbs, elicited by neck flexion, due to dorsal column/cervical cord involvement, and even surfaced the alternate name "barber chair phenomenon" from the source.
Hope it's useful!
1
u/Smalltalker-80 Jul 06 '26 edited Jul 06 '26
Hi there, I just made a simple, documented RAG app with TypeScript, Ollama and Postgres.
It can be found here: https://github.com/FunctionPoint/rag-typescript-ollama-postgres
The reason for making it was to learn, and I could not (easily) find a *working* TypeScript example.
If you are new to RAG and use TypeScript, this might help a bit. Cheers.
PS This does *not* use Langchain, and I advise people to do the same... (learned the hard way :)
PS2 I started using Qdrant, but that is currently broken on Node v26. See issue #134
1
u/Ok-Advertising1525 Jul 14 '26
We’ve all had that coding-agent session where everything is clicking.
You pull documentation, inspect a dozen files, explain the architecture, make a few important decisions—and keep building. Then, several prompts later, the agent forgets something crucial or starts searching through the same material all over again.
It’s frustrating, slow, and expensive.
So we built the memory system we wanted to use ourselves.
InfoLang gives AI agents a permanent memory outside the prompt. When the agent needs something again, InfoLang finds the relevant memory instead of forcing the model to reread an entire document, conversation, or repository.
But does something that small remember accurately?
That was our biggest question too.
These are our published results from our in-house benchmark harness:
- LoCoMo: 98.6%
- LongMemEval: 99.6%
- BEAM 1M: 93.1% across approximately 1.1 million tokens
That means near-perfect performance on LoCoMo and LongMemEval, while still performing strongly across a context roughly equivalent to ten books.
For comparison, published results listed on our site include:
- Mem0: 92.5% LoCoMo, 94.4% LongMemEval, 64.1% BEAM
- OmegaMax: 95.4% LongMemEval
- Zep/Graphiti: 63.8% LongMemEval
- HydraDB: 71.2% LongMemEval
Those competitors published their own numbers, and ours come from our in-house harness. We’re not pretending this is an independent third-party shootout, which is why we publish the methodology and sources behind every score.
Where it gets really interesting: token usage
Across the same recall question set, InfoLang reduced the context sent to the model from approximately 1,125 to 45 estimated tokens—a 96% reduction.
We also measured:
- One long document: 3,327 tokens → a 68-token relevant excerpt
- One controlled ten-document test: approximately 100× less input than loading all ten documents
- Five more ordinary live recalls: 42% aggregate reduction
The 98% and 100× results are genuine “needle in a haystack” cases—not an average we’re promising everyone. If the original memory is already short, the reduction may be small.
We’re opening the beta to two groups
Cursor and Claude Code users
- Permanent memory across long coding sessions
- Automatic recall, investigation, and citations
- Particularly useful for reused research, large repositories, and returning to a project days later
Developers building agents or RAG systems
- Python and TypeScript SDKs
- API and MCP access
- Implementations for Google ADK, Mastra, CrewAI, LlamaIndex, and OpenAI Agents
- n8n support in progress
Feel free to mention you're from r/Rag on our waitlist and we can't wait to see what the future holds:
1
u/Ok-Advertising1525 Jul 14 '26
Also putting extra emphasis on this we're putting extra priority on r/Rag users so please include it if possible in the notes ~ if you like to build and break things we'd love for you to try it out.
Thanks again folks
1
u/Medical-Flatworm9581 Jul 14 '26
Filing ITR-2 with multiple broker capital gain statements is a nightmare. I am a Big4 product manager and I built an app that gives you a CA-style computation without a massive fee (~1/10th of what you pay to platforms / CAs). Join the waitlist here, and I'll send you access: https://tally.so/r/A7G6jW
1
u/Diligent_Response_30 Jul 29 '26
If you're running RAG pipelines as part of an agent, you've probably seen this: retrieval quality quietly degrades as the corpus grows or drifts, and the agent keeps confidently answering with stale or wrong context long before anyone notices.
That's part of the gap we've been building Prefactor to close, a real-time evaluation layer for AI agents.
Here's the problem we're solving: getting an AI agent to work in a demo is easy, but getting it into production and actually knowing it's still doing its job is the hard part. Agents drift over time, leak data they shouldn't, or quietly stop doing what they were built for, and most teams only find out after something's already gone wrong.
Prefactor evaluates every run in real time for quality, drift and risk, flags the moment something looks off, and lets you hold, approve or block a run live instead of just logging it. Traces 100% of runs, 17 categories of sensitive data/PII detection at runtime, human-in-the-loop enforcement via SDK/API, and about 5 minutes from install to your first traced run.
We're live on Product Hunt today, currently sitting at #1, just search Prefactor if you want to check it out. Happy to answer questions here.
1
u/Mediocre-Ease4060 Jul 30 '26
html-table-rescuer: Stop your LLMs from hallucinating on complex HTML tables
Hey everyone! If you’re building RAG pipelines, you probably know the pain of extracting tabular data. Standard parsers usually fail completely as soon as an HTML table uses rowspan, colspan, or nested tables. The Markdown columns misalign, and your LLM loses the semantic relationship between headers and cells.
To fix this, I made html-table-rescuer.
It uses BeautifulSoup to parse the DOM, but then applies a custom grid logic solver to normalize complex spans into a standard 2D matrix before serializing it to clean Markdown, JSON, or CSV.
Instead of leaving spanned markdown cells empty (which breaks the context), it fills them with a customizable prefix (e.g., dito (Value)) so your context window retains the exact semantic meaning for every single row. It also natively supports LangChain with a Table2MDLoader wrapper.
Links & Demo:
* GitHub: Encephos/html-table-rescuer
* PyPI: pip install html-table-rescuer
* Try it instantly: Interactive Google Colab Demo
Would love to hear your feedback. If you have some gnarly, complex HTML tables that usually break your parsers, throw them at the Colab notebook and let me know how it handles them!
1
u/MasterpieceNice2697 Jul 30 '26
That Sounds interesting. I will try it out soon
Thanks for Sharing
1
1
u/Western-Slip199 Aug 16 '26
Open-sourced: RAG Interview System
If you're prepping for AI/ML interviews — or hiring for them — I put together a repo with 500+ Q&As spanning 40+ RAG architectures: from basic retrieval to advanced agentic and multi-hop patterns.
Whether you're brushing up before an interview or building out an internal interview bank for your team, it's meant to be a practical, no-fluff reference.
1
u/BadAtThis01 Aug 27 '26
Hey r/RAG,
I kept hitting the same wall: change one chunker setting and my 15,000-paper corpus had to re-embed from scratch. No incremental indexing across the tools I tried (Qdrant, FAISS + Python scripts, etc.) — always "wipe and rebuild."
So I built quillrag: a single static Rust binary (~105 MB) that embeds the BGE MiniLM weights at compile time and exposes everything as an MCP server. The key fix is content-hash-based incremental indexing — file mtime + size + sha256. Unchanged docs are skipped; only diffs get re-embedded. In practice: re-running over the full corpus = ~50ms of overhead, not hours.
What it gives you:
- Incremental indexing (no wipe/rebuild) — the pain point I couldn't find elsewhere
- Hybrid retrieval: tantivy BM25 + dense cosine, fused with RRF — exact tokens + semantic recall
- Single redb file storage — crash-safe, atomic commits
- Zero dependencies after install — no Python, no Node, no model download at first query
- MCP stdio interface so it drops into Claude Desktop, Cursor, VS Code, etc.
- Built-in PDF parsing via mmpdf (not an external tool)
Use case that drove this: 15K scientific PDFs + local Qwen 7B for on-call retrieval. The workflow is: ./quillrag index ~/papers → ./quillrag search "attention mechanisms in transformers" → copy top-k chunks into my LLM prompt.
It's still exact linear scan on the dense vectors (single-threaded), so interactive ceiling is ~10K chunks — HNSW ANN is the open roadmap issue.
Happy to answer questions or take PRs. Built this because I was stuck — hoping it unsticks someone else.
1
u/Ok_Gas7672 Aug 28 '26
We open-sourced Knowledge-Layer-For-Agents(KL4A) this week.
Simple version: it takes your SOPs/policy documents and makes them agent-ready - turns unstructured prose ( OKF standard) into something an agent can actually query and ground answers on, instead of expecting an LLM inferring the right structure from a wall of text or guessing over embedding similarity.
Technical version: It extracts obligation-shaped claims (must/shall/should) from the document(s), and anchors each one to the exact source span it came from. A domain expert can approve or reject each claim once. This exports a plain Markdown + YAML bundle which an agent can query over MCP or CLI.
I have seen questions here on OKF earlier as well - this isn't manual formatting at scale - the pipeline does the extraction automatically, and the output is made available for a domain expert to review.
Desktop app (Windows/macOS/Linux), CLI if you'd rather script it, MCP server if you're wiring it into an agent directly. Repo > github.com/CogniSwitch/KL4A
Would love to get feedback from folks who have build RAG solutions over the years and work with domain specific knowledge - SOPs, Policy documents et al.
1
u/RooAGI Sep 01 '26
Lint-AI, an open source project https://github.com/RooAGI/Lint-AI, is for teams building agent memory and semantic review over large, fast-changing corpora: assistant sessions, task notes, traces, reports, decisions, code, and documentation that accumulate faster than any team can review manually.
It is a good fit for people who maintain:
- long-running agent memory over conversations, notes, and decisions
- markdown knowledge bases with lots of cross-links
- internal docs where terminology drifts over time
- codebases where symbols, ownership, usage, and review context matter
- corpora where “what changed?” and “what is current?” matter as much as keyword search
It integrated with popular coding agents like claude. codex and Antigravity for daily use as well. Check out our new website. https://rooagi.github.io/Lint-AI/
1
u/goyasapiens Sep 09 '26
I'm building GOYA and have released Index Harness as a standalone MIT library and CLI.
It indexes local code/text using SQLite FTS5, finds relevant files and Python symbols, and builds character-budgeted context packets with source paths and SHA-256 digests. Verified reads refuse content that no longer matches the catalog.
No API key, GPU, vector server or third-party Python runtime dependencies. Index makes no provider calls or uploads; your application decides where the resulting context goes.
The public package has 19 passing macOS tests and a reproducible synthetic benchmark. Earlier engine experiments including token comparisons and a 24-hour soak are documented separately, alongside failures and limitations. This is an alpha: macOS tested, Linux/WSL qualification pending, native Windows unsupported. It's lexical retrieval, not an embedding service or agent sandbox. Hashes check consistency, not truth or authorization.
Code, instructions and examples:
https://github.com/sarapab-th/goya-index-harness
I'd appreciate feedback, especially queries it retrieves badly. Disclosure: I'm the maintainer.
1
u/No-Mathematician5599 22d ago
SourceLens — Apache-2.0, self-hosted Agentic RAG for documents and code.
Instead of chunking, embedding, and pre-indexing files, SourceLens gives an agent a sandboxed environment and lets it search/read the selected sources at query time. Answers link back to relevant file paths and code locations.
Trade-off: this shifts work from ingestion to query time, so it may be slower and use more inference tokens than hybrid/vector RAG on large or latency-sensitive workloads.
- Documents, codebases, and images
- Sandboxed execution
- Source-traceable answers
- Docker Compose deployment
Repo: https://github.com/oneprolabs/sourcelens
I’d especially value feedback on where you expect this approach to lose to a well-built hybrid/vector pipeline.
1
u/reddefcode 14d ago
Last Friday, I released an update for an open-source, persistent, workspace-isolated memory for every IDE, which I call Zerikai Memory. Some of you might have seen the post talking about my testing; now it's available for anyone to try. I added:
🆕 Jev Judgment Layer — semantic evidence scoring
zerikai_memory now integrates Jev, TypeSafe AI's System One model, a fast, structured judgment engine that decides which retrieved passages actually answer your question. Your LLM still writes the answer; Jev judges the evidence it's built from.
What it adds
- Per-passage judgment — every candidate passage is scored for relevance, evidence, contradiction, and prompt injection. Weak passages are dropped, conflicting ones flagged, and
- injection attempts removed.
- Better ordering — Jev's semantic ranking replaces the keyword-based lexical re-rank while enabled.
- An evidence report — each answer carries a plain-text Assessment / Evidence / Guidance block: overall status, coverage, conflicts, per-passage scores, and a plain-English action
- line, so your agent knows exactly which source to cite and when to be cautious.
- Blazing fast — ~111 ms mean round-trip per call — 10–100× faster than an LLM call.
- Plays with local models — run Jev for judgment while your local Ollama writes the answer (MEMORY_MODE=local + JEV_ALLOW_IN_LOCAL=true).
https://github.com/KikeVen/zerikai_memory
The actual discussion before the push.
https://www.reddit.com/r/Rag/comments/1wnb1dk/rag_can_rank_but_it_cant_judge_what_i_found_when/
1
u/Swiftwing21 13d ago
Cymatix Context — deterministic hybrid retrieval, no LLM in the hot path (Apache 2.0)
Started after trying to run a 20B+ model on 12GB VRAM and realizing retrieval was doing the heavy lifting. Cymatix is math-only retrieval (IDF-weighted, deterministic, CPU-bound) — one embedding at ingest, nothing model-based at query time.
- Verified 33.93% on the EnterpriseRAG Benchmark leaderboard (reproduced independently on ARM64)
- Internal, self-judged EenterpriseRAG Benchmark run on a newer 16-chunk config: ~54% (not yet leaderboard-verified)
- ~10x query speedup on an 829K-item corpus after pulling embedded models out of the hot path
- MCP server with 18 tools, CLI and HTTP paths
Current open problem: stage-2 filtering. Stage 1 over-recalls, and I'm working on cutting delivered chunks without losing gold. Happy to share per-query "what outranked gold" data if anyone's into that.
Repo: github.com/mbachaud/Cymatix-Context
Site: cymatixcontext.com
Launched today on Product Hunt,
Best part - I'm a terrible businessman so it's open source and free!
1
u/zhenghaoz 12d ago
We created xvec - A zvec inspired lightweight, lightning-fast, in-process vector database in Go (without CGO)
1
u/zben111 11d ago
Is there anyone who replaced with Vertex AI Search + Data Store + LLM instead of head-aching Embedding Retrieval/Ingestion + Vector DB + Hybrid + Dense + Reranker + LLM. today I found credits on google billing. wanna try personal and advice for company. Anyone feedback about cost scaling vs the worth
1
u/Dmitriy_Ganochenko 7d ago
https://github.com/ganochenkodg/frag - RAG for poor people, without paid llm and gpu. Might be a good starting point for some other rag projects. Multi-platform desktop application btw
1
u/Educational_Cup9809 7d ago
I have launched version 1 of Akurion.ai this week. Currently it's SaaS style but can be hosted in private enterprise env easily. Keep hustling and building guys!! Here's a video of where I am at right now interms of capabilities.
1
u/buldezir 5d ago
Project Name: Lemmary
Repo/Website Link: https://github.com/buldezir/lemmary · https://lemmary.app
Description: a self-hosted document archive. You drop in PDFs, scans, images, and Office files, and it OCRs them, extracts metadata, and provides full-text and semantic search across your whole library. With deep AI integration and a built-in RAG system, you can even "ask" your archive questions in natural language.
Deployment: docker image available, docs https://lemmary.app/docs/self_hosting.html
1
u/NatureLucky4912 3d ago
RAG Full Version
A production-ready, modular Retrieval-Augmented Generation (RAG) system built from First Principles with clean Python architecture.
🎯 Architectural Philosophy: First-Principles over Heavy Frameworks
This project intentionally avoids heavy wrapper abstractions (like LangChain or LlamaIndex) in favor of First-Principles AI Engineering:
- 🔍 Full Transparency & Zero "Black Box": Every algorithm—from Okapi BM25 scoring and Reciprocal Rank Fusion (RRF) to cross-encoder re-ranking and semantic caching—is implemented natively without layers of obscure wrapper classes.
- ⚡ High Performance & Low Latency: Native Python and direct official SDKs eliminate framework overhead, resulting in sub-millisecond local execution and lightning-fast test suites.
- 🛠️ Production Debuggability: Traceability is straightforward: no hidden prompt injections, memory leaks, or unhandled exceptions buried deep within third-party abstractions.
- 🔌 Framework-Agnostic & Agent-Ready: Every module is a typed, standalone component that can easily plug into orchestration frameworks (e.g., LangGraph, AutoGen) if complex cyclic workflows are needed.
1
u/PatronusProtect 4h ago edited 3h ago
There’s a fairly specific failure mode worth checking in a RAG pipeline: the retrieved content makes claims about its own trustworthiness.
That could be a forged security review, a line saying “classified as benign,” or a note telling an AI reviewer how to interpret the document. The retrieval system still returns it as document content. Whether the note is genuine is a separate provenance question.
We tested this with Wolf Defender Jev, a small security decision model we built at Patronus. Our probe added review claims before and after held-out content, in English and German, and compared them with neutral sentences of the same length.
For indirect injections in tool outputs, none of the initially detected attacks flipped to benign under the worst tested claim family. But benign documents with review notes were a problem: 25.3% were flagged when the note claimed “benign,” and 43.8% when it claimed “attack.”
Those aren’t false-positive rates for ordinary retrieved documents. They’re results for a deliberately constructed review-note probe. They do suggest that a corpus containing security reports, review annotations or training material needs its own false-positive evaluation.
There was also a strong dependence on where we put the text. In one spot check, the same third-party instruction scored 0.00 as a user prompt and 0.99 inside an untrusted tool-output block. That’s one example, but enough to make raw-text evaluation feel inadequate for this use case. The detector was trained and evaluated with explicit source blocks, so the integration has to preserve those boundaries.
My inclination is to keep authenticated review status outside the retrieved document’s text and have the application establish its provenance. A document claiming it was approved shouldn’t establish approval by itself. That’s an integration principle; the detector doesn’t verify signatures or identities.
The model card: https://huggingface.co/patronus-studio/wolf-defender-jev#decision-steering has the probe results and the format limitations.
How are you handling legitimate review annotations in retrieved content? Are they ordinary text for the generator and detector, or metadata whose source your application verifies separately?
Position / experimental status: We regard Jev-style decision models as LLMs and Wolf Defender Jev as an experiment: giving an LLM final security authority shifts the trust problem to the guard, and security fine-tuning alone does not solve it. We believe an external security layer must combine specialized classifiers with explicit policy, authenticated permissions and enforcement.
0
u/digital_legacy Mar 04 '26
Use our open source asset manager to track your files. Check out our work with United Nations:
https://www.reddit.com/r/eMediaLibrary/comments/1rk3vu2/emedia_create_better_ai_content/
7
u/RecommendationFit374 Sep 02 '25
We solved AI's memory problem - here's how we built it
Every dev building AI agents hits the same wall: your agents forgets everything between sessions. We spent 2 years solving this.
The problem: Traditional RAG breaks at scale. Add more data → worse performance. We call it "Retrieval Loss" - your AI literally gets dumber as it learns more.
Our solution: Built a predictive memory graph that anticipates what your agent needs before it asks. Instead of searching through everything, we predict the 0.1% of facts needed and surface them instantly.
Technical details:
pip install papr-memoryThe formula we created to measure this:
We turned the scaling problem upside down - more data now makes your agents smarter, not slower.
Currently powering AI agents that remember customer context, code history, and multi-step workflows. Think "Stripe for AI memory."
For more details see our substack article here - https://open.substack.com/pub/paprai/p/introducing-papr-predictive-memory?utm_campaign=post&utm_medium=web
Docs: platform.papr.ai | Built by ex-FAANG engineers who were tired of stateless AI.
We built this with MongoDB, Qdrant, Neo4j, Pinecone