Mohamed Elrfaey

Really exciting example by Jason Koo on how to convert web pages into graph representations with completely dynamic edges and nodes‼️ The trick? A really well defined schema that articulates the problem well. Hint: JSON schema was too verbose to work! Of course, the easiest way to do this was: 1. Neo4j for a great graph database and tooling 2. BAML (Boundary (YC W23)) for getting extremely high quality LLM responses Full blog post with code in the comments

165

8 Comments

A slow code review process delays shipping, while rushed reviews let bugs slip through. My friends at Graphite have launched Diamond, an AI-powered code review agent that delivers instant, high-signal feedback on every pull request. Diamond helps by catching logic errors, security vulnerabilities, and style inconsistencies before a human even looks at the PR. A few things that stand out:  - Customizable rules to match your team’s coding patterns  - Smarter comments with context from your codebase  - Suggested fixes you can accept with a click  - Works in any GitHub repo, no Graphite plan required It’s free for up to 100 PRs per month. Worth checking out: https://gt.dev/diamond 

474

12 Comments

My Take on “Agentic” Frameworks and Real AI Engineering: There’s a lot of excitement around “agentic” frameworks, OpenAI’s AgentKit, LangChain, LlamaIndex, and others, all promising to simplify how we build intelligent systems. They’re great for quick prototypes, but when you’re designing production AI products that have to last, the picture changes. To me, an agent isn’t a visual node or a black-box workflow, it’s simply a modular, testable class that performs a defined task using an LLM or transformer model under strict control. In other words, it’s just good software design: clear inputs and outputs, deterministic orchestration, and measurable results. I prefer to build hybrid systems that combine structured engineering with state-of-the-art NLP and transformer architectures, using the LLM as a controlled component, not the entire system. That keeps the logic transparent, debuggable, and adaptable as models and requirements evolve. Frameworks like AgentKit can still help at the edges, for evaluation, UI, or quick orchestration, but the core intelligence and logic should always live in code you own and understand. That’s how you build AI that’s not only powerful today, but maintainable tomorrow. #AI #MachineLearning #LLM #SoftwareEngineering #NLP #ProductDesign

49

4 Comments

How do you keep track of every process running at Google? Countless quadrillions of metrics emitted by billions of devices and VMs? This is a really cool paper that presents ten years of learnings from running Monarch, a planet-scale in-memory time series database that supports monitoring and alerting for much of Google’s applications and infrastructure. Monarch runs at massive scale, ingesting terabytes of data every second from billions of endpoints in datacenters across the globe, and needs incredible availability as it is a dependency of so many other Google services. Monarch’s scale and availability requirements informed two critical design decisions: it must prioritize availability over consistency and it must store data in memory. This is because a system like Monarch is most critical when things are breaking–in the case of a network or file system outage, Monarch needs to do the best it can to deliver as much data as possible to the engineers trying to fix it, not get stuck trying to make sure all metrics are consistent and durable. Thus, reads may serve partial data and all writes are best-effort, including replication and flushes to durable storage. To ingest terabytes of data every second, Monarch adopts a divide-and-conquer strategy. Incoming metrics are routed on multiple dimensions. First, they are routed based on location to a nearby collector. Then, they are lexicographically sharded based on their contents. Once a metric arrives at a Monarch server, it is stored in memory, then asynchronously (with best effort) written to recovery logs. To minimize the amount of data stored, particularly frequent metrics are aggregated during ingestion and only stored as cumulative series, not individual points. Processing queries in Monarch is also difficult because they have to be globally distributed to get data from all the instances of a service. This is done hierarchically, by multiple levels of query processors that fan out queries across data centers and servers. Each processor level tries to push down work to the lower levels, so as much of the query as possible is evaluated directly on the data. To minimize the degree of fanout, the upper levels store an index of which of their children contain which ranges of data, to ensure queries aren’t sent to children that don’t have relevant data. To ensure availability, if some parts of the system are unresponsive, queries will return partial data. What are the takeaways? What I found most interesting about Monarch is how it is designed to operate well during catastrophe. Most databases prioritize strong consistency guarantees–if a query can’t be answered correctly (or data can’t be written durably), it isn’t answered at all. But Monarch needs to work even when everything else is broken, so at every level of its stack it prioritizes availability, getting as much data as possible to the engineers trying to fix a problem. That’s a valuable lesson–match your guarantees to what your users need!

415

8 Comments

dbt Labs acquires SDF Labs. 💰 It's kinda big, one of the biggest pain of dbt Core is the speed of compilation and SDF brings a tech that speeds up while giving a large understanding of SQL patrimony. SDF brings lineage and core mechanism to unsure nothing breaks with static analyses. This move also feels like a way to compete with SQLMesh vision as I see SQLMesh and SDF Labs with a similar conclusion to issues dbt Core brings. Tho I still think there is something unanswered regarding the UX and especially the UI that we are addressing with nao Labs. But stay tuned 🤭 ➡️ https://lnkd.in/dnAX4xDe

111

8 Comments

The o3-mini reasoning model, launched in January 2025, delivers advanced STEM capabilities with low latency and cost—63% cheaper than previous models! Roger Barreto shares how this is now available in Azure OpenAI Service, it features reasoning effort control, structured outputs, and native tool integration. 🔧 Learn how to integrate o3-mini into Semantic Kernel with just a few lines of C# or Python. Ready to optimize your AI applications? Let’s dive in! ⬇️ https://lnkd.in/geiWrT8P #AI #SemanticKernel #OpenAI

32

1 Comment

📣 Introducing RRE-1: A New Model for Retrieval Evaluation & Reranking for RAG based applications. Retrieval-Augmented Generation (RAG) has massively helped transform LLM-powered applications, but let’s face it—retrieval quality is still the weakest link in many pipelines. Poor retrieval is one of the major contributors of lower accuracy of your LLM applications. 🧐 That’s why we at AIMon built RRE-1, a powerful retrieval evaluation and reranker model designed to optimize ranking quality at scale. 🎯 👉 Why does this matter? Traditional retrieval methods like vector search are powerful, but they have limitations in effectiveness, especially when handling complex queries and domain specific knowledge. RRE-1 addresses this by offering: ✅ Offline evaluation of retrieval effectiveness, helping teams benchmark and refine their pipelines. ✅ Real-time low-latency reranking to ensure the most relevant context reaches the LLM. 👉 Who is this for? If you’re working on LLM agents, enterprise RAG systems, or AI copilots, this is for you. Our model ensures your retrieval pipeline is as optimized for your generative model—because great responses start with great retrieval. 🔎 Want to see it in action? Read more about AIMon RRE-1 in our blog post (link in comments). If you’re tackling retrieval challenges in your AI stack, we would love to chat! #AI #RAG #Retrieval #LLMs #MachineLearning

67

4 Comments

Not all large language models are created equal. The architecture behind an LLM determines how fast it runs, how well it scales, and where it shines. Here are 6 architectures every AI builder should know: ➤ 1. Encoder-Only → Focus: Deep understanding, embeddings → Trained on: Masked tokens → Ideal for: Search, classification Examples: BERT, RoBERTa ➤ 2. Decoder-Only → Focus: Next-token prediction → Trained on: Left-to-right context → Ideal for: Chat, code, agents Examples: GPT-4, Claude, LLaMA ➤ 3. Encoder-Decoder (Seq2Seq) → Focus: Input → Output mapping → Trained on: Paired data → Ideal for: Translation, summarization Examples: T5, BART ➤ 4. Mixture of Experts (MoE) → Focus: Sparse routing for scale → Trained on: Expert selection → Ideal for: High performance, lower cost Examples: GLaM, DeepSeek-V2 ➤ 5. State Space Models (SSMs) → Focus: Long context, fast compute → Trained on: State transitions → Ideal for: Large documents, low latency Example: Mamba ➤ 6. Hybrid Models → Focus: Best of all worlds → Trained on: Mixed paradigms → Ideal for: Balanced performance Examples: Jamba, Grok 🌟 Follow the AIKaDoctor (Free AI & Data Science Resources)  channel on WhatsApp: https://lnkd.in/dCTCEKKc 📌Follow Habib Shaikh For more such content.

220

24 Comments

⛑️ OpenAI released Sora 2 and an invite-based iOS social video app (U.S./Canada first). The model adds synced audio, stronger physics/realism, and more steerability. A consent-gated “cameo” feature lets verified users allow trusted friends to use their likeness. A System Card outlines safety limits (e.g., upload restrictions, teen safeguards, ongoing moderation). Ultra-realistic, social-by-default video raises new operating questions for enterprises: managing likeness rights, verifying provenance/watermarks, setting pilot guardrails for brand and copyright risk, and mapping controls to your governance framework (e.g., NIST RMF / ISO 42001). Early momentum is real—and so are concerns over deepfakes and harmful content—so policies should ship before pilots scale. 👉 If your org could access Sora 2 today, what’s the first written rule you would require before launching a pilot? #AILeadership #AIGovernance #Sora2 #GenerativeAI #AIVideo #Provenance #Watermarking #TrustAndSafety #Deepfakes #RiskManagement #NIST #ISO42001 #BoardOversight #GenAIGlobal Tap follow for no-fluff AI news & insights from MIT’s Gen AI Global founder Oscar Sanchez 🧠

21

1 Comment

"When AI models are open source, it encourages innovation. Developers, amateur hobbyists, and academic researchers can all access cutting-edge algorithms, models and tools without prohibitive costs." Read Yaron Inger's latest Techzine piece to understand why we at Lightricks decided to release LTX Video as an open source model:

47

4 Comments

Most AI tools today are thin LLM wrappers. Here’s how we built Vectice differently. When people ask, “Why not just use GPT to write my model documentation directly?” it sounds reasonable. Until you look closer at what’s really required. If we take the example of a model validation documentation, the document must show: - Which dataset version was used - The exact code and parameters that produced the results - Metrics and thresholds agreed with governance - Plots that match the evidence - Section content aligned with internal policies and regulators’ templates An LLM on its own can’t guarantee any of that. At best, it produces well-worded but disconnected content. At worst, it hallucinates numbers, forgets context across sections, or drifts in tone. That’s why Vectice looks more like a multi-agent orchestration platform than a LLM wrapper: - Autolog listeners capture raw evidence across notebooks, CI/CD, and registries ( code, data, iterations, metrics... ) without manual copy/paste. - An autonomous evidence graph normalizes artifacts, assigns stable IDs, and enables point-in-time reconstruction. - Agents review content, decide which sections can be generated safely, and insert plots and tables directly from evidence, not memory. - A knowledge base aligns prompts with regulatory standards like SR 11-7 or the EU AI Act. - The orchestrator ensures determinism with retries, timeouts, parallelization, and smallest-capable LLM routing for cost control. The result isn’t “a single shot LLM wrote this.” It’s a multi-agent choreography where every sentence, figure, and table is anchored to evidence: traceable, citable, and reproducible. That’s where the new generation of vertical startups are building their defensive moat. They aren’t threatened by LLMs, or vibe coding, they’re anchored in defensive IP, industry-specific workflows, and months of prompt tuning and orchestration. The next generation of LLMs may be smarter tomorrow. But will they know how to generate a compliant SR 11-7 document you can trust on their own? We’re confident they won’t.

53

3 Comments