QueryWeaver: Complex Text-to-SQL with Knowledge Graphs

QueryWeaver actually started as a demo for FalkorDB. We wanted a quick way to showcase how graph traversal can help LLMs understand complex database schemas. But the response was surprising, many teams building Text-to-SQL are hitting the same problem once schemas get large and interconnected. What began as a simple demo quickly turned into something people were actively looking for. Turns out graphs + LLMs is a very practical combination.

**The Shape-Shifting Index** What if your search index could change its own structure, depending on whether it is writing data or reading it? When building the storage engine at Infino AI, we faced a classic tradeoff: optimize for fast writes OR fast reads. We chose both. The trick: use one structure while data is flowing in, then automatically transform it into a completely different structure once that chunk of data is complete. The read-optimized version is usually an order of magnitude smaller in memory and significantly faster at searching. This isn't a new idea, it is the same principle behind how most modern databases handle the transition from "still changing" to "done changing." Once you know data won't change, you can organize it in ways that would be too expensive to maintain during writes. Sometimes the best answer to "which data structure should I use?" is: why not both? Full write-up with code and benchmarks: https://lnkd.in/dYEtgaP7 #databases #systemdesign #searchengines #dataengineering #rust #softwarearchitecture

The access patterns of agentic queries are starting to reshape how data infrastructure needs to be built. Agents don’t just retrieve documents. They perform iterative lookups, joins, filtering, aggregation, and reasoning across structured and unstructured data. That changes the optimization problem for databases and search engines. Vinay Kakade shares how we think about this in the context of Infino’s storage engine. #Databases #AI #AgenticSearch #Search

Data Debug brought three practitioners to Mux's office this past Tuesday to answer one question: how do you make AI actually reliable for data work? The talks told a complete story. Claire Gouze CEO/Founder at nao Labs (YC X25) benchmarked 21 AI analytics tools on text-to-SQL accuracy. The headline finding: going from no context to a cleaned data model jumped accuracy from 17% to 86%. Semantic layers alone? 4% correct. Context quality is everything. Our own Dori Wilson shared the AI skills framework she built to operationalize that context. Skills are markdown files that encode domain knowledge, workflows, and guardrails into AI coding tools. Structured as a self-improving loop, every session compounds. She walked through a real aggregation bug Claude introduced, how a review skill caught it, and how the fix became a permanent rule the system enforces automatically. Kasia Rachuta (Lead Data Scientist) showed the breadth of what's possible today: analyzing CS tickets with Snowflake Cortex AI, fuzzy address matching that beat regex by 20%, automated Slack responses from documentation, and ETL doc generation. The practical filter: knowing when AI saves time versus when it's faster to write the code yourself. All three full talks are now on YouTube. See them here: https://lnkd.in/g6f_TxSP Data Debug SF runs monthly. If you're building with AI in data, this is the room to be in. #DataDebugSF #DataEngineering #AnalyticsEngineering #AI #dbt

Most devs use AI after a query is slow. Better devs use it before writing the query. Instead of: “Optimize this SQL query” Try this: Step 1 — Intent-first prompt “Given this feature, design the most efficient data access pattern with indexes” Now AI thinks in: • access patterns • read/write ratio • index strategy • query shape Not just syntax. Step 2 — Force constraints “Assume 10M+ rows, avoid full table scans, optimize for pagination” This changes the output completely. You’ll get: • composite indexes instead of single ones • cursor-based pagination instead of offset • selective projections (no SELECT *) 💡 Advanced trick: Ask AI to simulate: “Explain how this query executes step-by-step (like query planner)” It will expose: • hidden scans • bad joins • index misses This is insanely useful when you don’t want to rely blindly on EXPLAIN plans. Great performance isn’t about fixing queries. It’s about designing them correctly before they exist. #SystemDesign #Databases #SQLOptimization #PerformanceEngineering #AIAgents #AdvancedCoding #ScalableSystems

🔍 Vectorless RAG Traditional RAG relies on embeddings + vector search: - Chunk data - Convert to embeddings - Store in a vector DB - Retrieve via similarity Sounds elegant… until it breaks: ❌ Semantic drift ❌ Poor retrieval for structured / tabular data ❌ Expensive re-indexing ❌ Hard to debug relevance ⚡ Vectorless RAG flips the paradigm Instead of relying on embeddings, it uses: - Metadata filtering - Keyword / lexical search - Structured querying (SQL, graph, APIs) - Context-aware retrieval logic No vectors. No embeddings. Just precise retrieval. 💡 Why it’s often more effective: 1. Deterministic retrieval > probabilistic similarity You get exact matches, not “closest guesses.” 2. Better for structured data Works seamlessly with databases, logs, tables. 3. Lower latency & cost No embedding generation or vector storage overhead. 4. Debuggable pipelines You can trace why something was retrieved. 5. Less context poisoning Cleaner, more relevant inputs → better outputs. 🧠 When to use Vectorless RAG: - Internal tools (dashboards, logs, enterprise data) - SQL-heavy or API-driven systems - Domains where precision > semantic fuzziness 🤖 When traditional RAG still wins: - Unstructured text (docs, PDFs, knowledge bases) - Semantic search across large corpora 🚀 The real takeaway: The future isn’t vector vs vectorless — it’s hybrid RAG systems that combine both intelligently. Stop defaulting to embeddings. Start designing retrieval. #AI #RAG #GenerativeAI #LLM #MachineLearning #AIEngineering #SearchSystems

Spent the last few weeks going deep on RAG systems, and honestly? There's so much more to it than just "retrieve some docs and pass them to an LLM." Here's what a truly robust RAG pipeline actually looks like 👇 Indexing is where most teams underinvest. Naive chunking kills retrieval quality. The real game-changers are Semantic Splitting, Multi-Representation Indexing (store summaries, not just raw chunks), Special Embeddings like ColBERT, and Hierarchical Indexing with RAPTOR for multi-level clustering. Your retrieval is only as good as your index. Query Construction isn't just "embed the question." Depending on your data, you might route to a Vector DB, a Relational DB, or even a Graph DB — each needs a different query strategy. RAG Types matter more than people think. → Multi Query & RAG Fusion for diverse retrieval coverage → HyDE for when you want the model to imagine the answer first → Decomposition for breaking complex questions into smaller, answerable pieces Routing is the silent hero. Logical routing picks the right database. Semantic routing picks the right prompt. Both are crucial for production systems. Retrieval isn't done after the first pass — Refinement and Reranking separate "good enough" from "actually reliable." Generation closes the loop — Self-RAG, Active Retrieval, and RRR patterns let the model decide when to retrieve more, not just blindly trust the first context it gets. And none of this matters if you skip Eval. RAGAS, DeepEval, and Grouse give you actual signal — not vibes — on whether your system is working. RAG isn't a feature. It's an engineering discipline. If you're building AI applications on top of enterprise data, you can't shortcut this. The teams winning right now are the ones treating RAG like a proper system — not an afterthought. What part of your RAG pipeline do you think most teams get wrong? Would love to hear in the comments 👇 #RAG #GenerativeAI #LLM #AIEngineering #MachineLearning #VectorSearch #AzureAI #EnterpriseAI

This month Dataiku made 3 major product announcements as part of the launch of The Platform for AI Success, and today we’re diving into the final piece of the puzzle! Dataiku Reasoning Systems: 🧠 Most organizations today are increasingly using Agentic AI as "point solutions"—isolated projects that solve one small problem but don't scale across the enterprise. With Dataiku Reasoning Systems, we help you transcend these silos to reach the highest level of AI maturity: The Reasoning Enterprise. 🛠️ It’s about more than just a chatbot; it’s about a full reasoning layer that orchestrates the entire end-to-end process. These systems don't just "act"—they plan, verify, and improve, turning fragmented agents into a continuous, self-improving workforce. 🚀 Unlike rigid coding assistants, Dataiku Reasoning Systems provide a unified framework where logic is transparent and auditable. You move from project-level controls to enterprise-scale impact, ensuring every autonomous decision aligns with your business goals. Want to know more? Have a look at the video or drop me a message. #Dataiku #AI #AIGovernance #ReasoningSystems #AgenticAI #TheReasoningEnterprise https://lnkd.in/dJEGwadx

🚀 Just built something I'm really proud of — Enterprise AI Data Assistant! Most AI assistants are either good at answering FAQs OR querying databases. I built one that does both — intelligently. 🧠 How it works: A Semantic Router first classifies the user's query: → FAQ-type? → Goes to RAG pipeline (ChromaDB vector search) → Structured query? → LLM converts it to SQL → runs on SQLite → Both paths feed into Groq LLM for a final response 🛠️ Tech Stack: • Routing: Semantic Router • Embeddings: Sentence Transformers • Vector DB: ChromaDB • Database: SQLite • LLM: Groq • UI: Streamlit • Language: Python 💡 What makes it interesting: → Hybrid architecture — RAG + Text-to-SQL in one system → Guardrails to prevent unsafe/invalid SQL execution → Schema-aware querying → Clean Streamlit chat interface This project taught me a lot about semantic routing, query classification, and building safe AI systems. 🔗 GitHub: https://lnkd.in/gGXRU2z9 Feedback welcome! 🙌 #AI #RAG #TextToSQL #LangChain #GenerativeAI #Python #Streamlit #LLM #ChromaDB #EnterpriseAI #Groq

One liner of the day #44 I have worked on One Big Tables (OBT) to simplify SQL, turns out they mirror how LLMs use data, denormalized, self-contained context chunks that don't require schema reconstruction. OBTs were RAG-ready before RAG existed. #DataEngineering #DataArchitecture #AnalyticsEngineering #AI #LLMs #RAG #MachineLearning