LLMs as RDF clients: unlocking LOD insights and synergy

𝗚𝗼𝗼𝗱 𝗻𝗲𝘄𝘀 𝗗𝗮𝘁𝗮 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀!  𝗬𝗼𝘂 𝗻𝗼 𝗹𝗼𝗻𝗴𝗲𝗿 𝗻𝗲𝗲𝗱 𝘁𝗼 𝗱𝗲𝗯𝘂𝗴 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 𝗳𝗮𝗶𝗹𝘂𝗿𝗲𝘀 𝗺𝗮𝗻𝘂𝗮𝗹𝗹𝘆✨ The GCP Pipeline Guardian🛡️ phase 2: AI-powered error analysis- is here!💥 How it works (end-to-end in seconds): BigQuery Error (Scheduled Query / Data Transfer Job / Manual Query) → Cloud Logging → Pub/Sub → Cloud Function → Gemini AI → Automated Analysis — 𝐚𝐥𝐥 𝐢𝐧 𝐬𝐞𝐜𝐨𝐧𝐝𝐬!! No dashboards. No manual checks. 𝐉𝐮𝐬𝐭 𝐫𝐞𝐚𝐥-𝐭𝐢𝐦𝐞 𝐞𝐫𝐫𝐨𝐫 𝐢𝐧𝐭𝐞𝐥𝐥𝐢𝐠𝐞𝐧𝐜𝐞 — end-to-end, fully automated. Explore the project: https://lnkd.in/gFEBWUYU 💡Phase 1 : https://lnkd.in/gRDAbKdh (Foundation, Historical analysis) Can we do more? 𝑨𝒃𝒔𝒐𝒍𝒖𝒕𝒆𝒍𝒚 𝒀𝒆𝒔! Stay tuned for what’s next. #DataEngineering #GoogleCloud #BigQuery #PubSub #CloudFunctions #Gemini #AIEngineering #PipelineGuardian

💡 Bringing Intelligence Closer to the Data This week, I successfully deployed an offline Large Language Model (LLM) integrated with MCP servers and connected it to my AdventureWorks PostgreSQL database. The setup allows the LLM to query, interpret, and summarize data insights directly — without relying on the cloud. This means faster response times, enhanced privacy, and total control over the data pipeline. It’s fascinating to see how combining LLMs with database intelligence can transform traditional systems into smart, context-aware data environments. This project demonstrates the power of AI when applied thoughtfully — it’s not just about automation, but about enabling systems to reason, communicate, and adapt. #AI #DataEngineering #PostgreSQL #LLM #Innovation #OfflineAI #MCP #DataAnalytics #MachineLearning #TechLeadership

I finally got around to validating something I suspected for a while and thought I'd share, since it's relevant to a lot of folks in my circles. 𝗧𝗟;𝗗𝗥: 𝗪𝗮𝗿𝗲𝗵𝗼𝘂𝘀𝗲-𝗻𝗮𝘁𝗶𝘃𝗲 𝗥𝗔𝗚 𝗶𝘀 𝗻𝗼𝘁 𝗼𝗻𝗹𝘆 𝘃𝗶𝗮𝗯𝗹𝗲, 𝗶𝘁 𝗶𝘀 𝗰𝗹𝗲𝗮𝗻. We can have RAG pipelines that feel like SQLMesh or dbt pipelines: declarative, reproducible, tunable, and just SQL. ✅ Recently I built a full RAG pipeline 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆 𝗶𝗻𝘀𝗶𝗱𝗲 𝗕𝗶𝗴𝗤𝘂𝗲𝗿𝘆: • Vectors in repeated 𝗙𝗟𝗢𝗔𝗧𝟲𝟰 columns with vector indexes - https://lnkd.in/ejYbQPtH • Hybrid search using 𝗧𝗘𝗫𝗧_𝗔𝗡𝗔𝗟𝗬𝗭𝗘, BM25, and IDF - https://lnkd.in/eWT6t5wU • Embeddings via 𝗠𝗟.𝗚𝗘𝗡𝗘𝗥𝗔𝗧𝗘_𝗘𝗠𝗕𝗘𝗗𝗗𝗜𝗡𝗚 for extremely high-throughput generation - https://lnkd.in/eK-2_yTM • Context enrichment with 𝗔𝗜.𝗚𝗘𝗡𝗘𝗥𝗔𝗧𝗘_𝗧𝗔𝗕𝗟𝗘 inspired by contextual retrieval patterns - https://lnkd.in/efU94sUR All with 𝗻𝗼 𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗶𝗱𝗲𝗰𝗮𝗿, no pipeline glue, no quiet background services multiplying operational debt. Everything lived where the data already lives and the experience honestly felt… nice. This is not to take away from the innovation of dedicated vector stores. They matter and have differentiators. But for maximizing operational simplicity, this path is compelling. And the interesting part was not performance. It was how much complexity disappeared once I stopped assuming RAG needed its own ecosystem. Some things just clicked: • Data comes in once • Retrieval happens near storage and can be enriched with 𝗟𝗘𝗙𝗧 𝗝𝗢𝗜𝗡s • Context shaping is a table transform • It scales without babysitting 👀 Feels less like an "AI stack" and more like a practical pattern for teams who care about maintainability, data gravity, and colocation. Not prescribing this as the "right way". As always, it depends. But it is probably a valid path for a lot more teams than we admit. Sometimes we do not need more infra. We need 𝗳𝗲𝘄𝗲𝗿 𝗮𝘀𝘀𝘂𝗺𝗽𝘁𝗶𝗼𝗻𝘀. Don't copy what you see if it seems too complicated. Think about it for awhile. ✨ If you are doing something similar already, let me know and tell me about it 🙂 I don't think this is overly "innovative" as much as I just don't see content in this vein. So, maybe it is? You tell me.

Thanks for sharing your opinion Christian but I disagree. Stuff like file search + embeddings + citations might be commoditized. But in my view, that's not what makes a good RAG solution. A good RAG solution lives and dies by understanding your use cases, the very nature of your documents, and how your users want to interact with these documents. A few thoughts from what I’ve seen: - Semantic search isn’t magic and it’s not one-size-fits-all. As soon as you move beyond simple Q&A on flat docs, plain vector search often disappoints: it misses context, gives shallow answers, or makes things up because it pulled the wrong snippets. - For many “give me a solid overview” tasks, hierarchical summaries might actually work better than retrieval. If you’re dealing with long reports, legal docs, research, etc. building layered summaries can give far more reliable results than hoping top-k retrieval happens to find everything important. - When you’re asking questions that span several related documents – with entities, relationships, timelines, dependencies – pure embeddings usually hit a wall. That’s where knowledge graphs or at least explicit linking between entities become crucial. That's why I think the real value (and hard work) is still in designing your own knowledge base and retrieval strategy around your domain and users.

🚨 Google just made #RAG a commodity with the new #Gemini File Search API. 1. Upload your corpus of files 2. Chat with your documents - including citations This shows me that investing in custom #RAG solutions is probably no longer a good strategic decision, when it gets wrapped into convenient enterprise services. Microsoft #Azure AI Search provides almost the same experience. Amazon Web Services (AWS) #Bedrock #Knowledge #Bases also get's close to this. • Fully managed RAG: No more stitching together storage, chunking, embeddings, and retrieval. File Search handles the entire pipeline for you — directly inside the generateContent API. • Free storage + free embeddings at query time: You only pay $0.15 / 1M tokens when you first index your files. Everything else is free, making retrieval dramatically more affordable and easier to scale. • Powerful vector search: Built on state-of-the-art Gemini Embedding models, enabling semantic search across your content — even without keyword matches. • Built-in citations: Gemini responses automatically reference the exact document sections used. Verification included by default. • Broad format support: PDF, DOCX, TXT, JSON, code files, and many more. #AI #RAG #Trend #Commodity #Cloud #Explainable Aleksandar Marjanovic Dominic Böni Andrija Ljubojević Andrea Perl

Financial institutions manage vast volumes of documents, scattered across various formats and systems. Manual collection and review slow teams down and increase the chance of errors. Document intelligence offers a better way. It can read and connect structured, semi-structured, and unstructured data across local and cloud sources. This solution utilizes a multiagent system powered by MongoDB’s document model, Atlas Vector Search, and Voyage AI by MongoDB’s voyage-context-3. Learn more. https://lnkd.in/dN2WmtSn #AISolutions #AI #RAG #AgenticAI #A2A #Agent2Agent #AIAgents #AIML #AI #ML #LoveYourDevelopers #LifeAtMongoDB #MongoDB #MongoDBAtlas #Finance #Services #AppDevelopment #POC #Demos #AgenticRAG #LLM #Embeddings #Vectors #LexicalSearch #LangGraph #LangChain #API #tools #GenerativeAI #GenAI

𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝘃𝗲 𝗔𝗜 𝗣𝗼𝘄𝗲𝗿𝗲𝗱 𝗥𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗮𝘁𝗶𝗼𝗻 𝗘𝗻𝗴𝗶𝗻𝗲 𝗼𝗻 𝗔𝘇𝘂𝗿𝗲 (𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲) 𝗜’𝘃𝗲 𝗯𝗲𝗲𝗻 𝗲𝘅𝗽𝗲𝗿𝗶𝗺𝗲𝗻𝘁𝗶𝗻𝗴 𝘄𝗶𝘁𝗵 𝗮 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗿𝗲𝗮𝗱𝘆 𝗽𝗮𝘁𝘁𝗲𝗿𝗻 𝗳𝗼𝗿 𝗔𝗜 recommendations on Azure combining GPT embeddings, a vector DB, and classic ranking rules. Diagram attached. 𝗧𝗟;𝗗𝗥 Use GPT to embed users/items → store vectors → retrieve similar items fast → apply business rules → ship ranked recommendations through a low-latency API. 𝗛𝗢𝗪 𝗜𝗧 𝗪𝗢𝗥𝗞𝗦 (𝗘𝗡𝗗-𝗧𝗢-𝗘𝗡𝗗) Data sources: User actions & item metadata → Blob Storage + Cosmos DB Embeddings: GPT creates vectors for items & user context Serving: Deployed via Azure Machine Learning (Model Endpoint) API Gateway: Azure API Management for auth/routing/quotas Caching: Azure Cache for Redis for hot embeddings 6–8) Orchestration: Azure Functions for cache check + model calls Retrieval: Chroma vector DB k-NN similarity search Ranking: Re-rank with business rules (freshness, availability, margin, diversity) Delivery: Results returned via API to the user 𝗪𝗛𝗬 𝗧𝗛𝗜𝗦 𝗣𝗔𝗧𝗧𝗘𝗥𝗡 Low latency: Redis + Functions keep P95 tight Personalization: Embeddings capture behavior & content nuance Control: Rule-based re-rank aligns with business goals Composable: Swap vector DBs/models without breaking contracts 𝗧𝗘𝗖𝗛 𝗦𝗧𝗔𝗖𝗞 Azure ML • Azure OpenAI/GPT • Cosmos DB • Blob Storage • Azure Functions • Azure API Management • Azure Cache for Redis • Chroma (Vector DB) 𝗢𝗣𝗦 𝗧𝗜𝗣𝗦 Batch + on-demand embeddings (catalog vs. user context) Version your vectors (index per model/version; safe rollouts & A/B) Pipelines with AML for retraining & index refresh Guardrails & observability (APIM throttling, App Insights, vector recall dashboards) Curious how you’d adapt this for your catalog size and SLA targets. ♻️ Repost this to help someone who needs it. ➕ Follow Mohamad Alayoubi〽️ for more insights and resources. M⌁⥅ #Azure #GenerativeAI #RecommenderSystems #VectorSearch #MLOps #RAG #OpenAI #CosmosDB #AzureFunctions #APIManagement #Redis #Chroma

When my $4K DGX Spark arrived, it taught me something I didn’t fully appreciate until I left the cloud: Even with great hardware and fast storage, a modern AI application won’t run if you’re missing the architectural layers hyperscalers provide implicitly. GCP had been doing a lot more “thinking” on my behalf than I realized—governing placement, enforcing data locality, avoiding egress, balancing cost vs latency, and shaping workload behavior through policy, not YAML. Standing up the Virtual CTO Advisor on bare metal exposed the missing piece: Layer 2C — the Reasoning Plane. A layer that sits between orchestration and runtime and turns infrastructure into an intelligent system. Once that layer clicked, it reframed how I see the rest of the stack. And it clarified a question I get all the time: “Is VAST Data an AI Platform?” No—and that’s exactly its strength. VAST sits cleanly in Layer 1 of the 4+1 Model: 1A: Governed storage 1B: Context management & vector retrieval 1C: High-throughput data pipelines It’s the Data Plane. It feeds your models. But it doesn’t run them. And it doesn’t orchestrate them. And it shouldn’t. The confusion only exists because the industry continues to collapse layers that should stay separate. I wrote a new post breaking down where VAST fits in the modern AI stack and why the DGX Spark moment made that boundary impossible to ignore. 👉 Read the full breakdown: https://lnkd.in/gwnxFf-g

🔍 How AWS OpenSearch Works — and How to Reduce Search Latency Ever wondered what happens behind the scenes when you perform a search in OpenSearch? 🤔 Recently, I got the opportunity to lead the OpenSearch setup in my organization, which turned into a deep learning journey — helping me truly understand how distributed search engines work under the hood. OpenSearch (the open-source fork of Elasticsearch) is a powerful, distributed search engine that powers everything from log analytics to e-commerce search. When you hit “search”, your query travels through a coordinating node, fans out to multiple shards, each shard executes the query, and then results are ranked and merged before being returned. But sometimes, searches feel slow — and here’s why 👇 Too many shards or replicas Wildcard or regex-heavy queries Large, unoptimized mappings Memory pressure or hot shards To speed it up: ⚙️ Design smarter indices – fewer shards, right field types (keyword vs text) 🔎 Optimize queries – use filters (cached), avoid scripts & regex, paginate with search_after 💾 Use caching – query & shard caches for frequent requests 🧠 Tune infra – allocate 50% RAM to JVM heap, use SSDs, balance shards 📊 Monitor constantly – track SearchLatency & JVMMemoryPressure via CloudWatch or Performance Analyzer Leading this setup gave me a deep, hands-on understanding of how OpenSearch behaves under load — from query execution flow to index optimization. Through continuous experimentation and tuning, I learned that achieving great search performance isn’t about one magic setting — it’s about balancing architecture, data modeling, and observability. With the right design and optimizations, OpenSearch can easily return millions of results in milliseconds.⚡ #learning #BackendEngineering #KnowledgeSharing

Ever wondered where all your LLM tokens (and budget) disappear? You prep a simple JSON, send it to your model…and suddenly your cheese is gone ! 😱 ⭐ Enter TOON —Token-Oriented Object Notation !!! ⭐ A clever, compact, LLM-friendly way to serialize your data. It’s like JSON went on a strict diet. 💰 If you’re building prompt pipelines or sending structured data to LLMs, this could lower LLM cost, still structured & readable. Here’s why it’s cool: 💡Uses 30–60% fewer tokens than formatted JSON. 💡Human-readable: Indentation (like YAML) + tabular rows (like CSV) for uniform data. 💡Schema-aware: You can declare fields once, then stream rows — making it easier for LLMs to parse and validate. ⏩ Explore TOON at https://lnkd.in/d6iC3GgD — The README is a great starting point with all the basics. #AI #LLM #JSON #MachineLearning #FinOps #Devops #MLOps #AWS #TokenOptimization #RAG #CNCF #Cloud #LLMOps #DeveloperTools #TechInnovation