标签：#AI

Jendrik Jördening shares practical engineering strategies for integrating LLMs into production pipelines. He discusses overcoming non-determinism, restricting schemas, separating semantic text extraction from deterministic code, and validating choices using discriminator models. Learn how to structure LLMs with an MVC approach to ensure database integrity, observability, and system reliability. By Jendrik Jördening

Researchers found that a metabolite produced by gut bacteria can weaken the barrier that protects the brain and promote changes associated with the cognitive disease.

As part of a restructuring, OpenAI reportedly disbanded a team that assesses the potential for catastrophic risks with its models.

I don't star GitHub repositories just because they are popular. A repository earns a star from me when I can see myself returning to it later. Maybe it solves a real engineering problem. Maybe it introduces a new architecture. Maybe the code teaches me something. Or maybe it represents where AI development is heading. I've been spending a lot of time exploring AI repositories around agents, workflows, RAG, MCP, browser automation, model training, and API development. These are seven repositories that stood out to me recently. Not because you need all seven. But because each one represents an important direction in AI development. 1. OpenAI Cookbook Repository: https://github.com/openai/openai-cookbook If you're building with the OpenAI API, this is one repository I would keep bookmarked. The OpenAI Cookbook contains practical examples and guides covering common API development tasks, with many examples written in Python. What I particularly like is the implementation-first approach. Instead of spending hours reading theoretical explanations, you can study working examples and adapt them to your own application. It's useful for: API integration Structured outputs Embeddings Agents Evaluations Multimodal applications For beginners, it can also serve as a bridge between understanding an AI concept and actually implementing it. 2. LangChain Repository: https://github.com/langchain-ai/langchain LangChain remains one of the most important repositories in the LLM application ecosystem. But I don't recommend it simply because it is popular. I recommend understanding it because it exposes you to the building blocks behind modern AI applications. Models. Tools. Retrievers. Agents. Integrations. Structured outputs. If you're serious about AI engineering, studying how these components fit together is valuable even if you eventually choose another framework. 3. LangGraph Repository: https://github.com/langchain-ai/langgraph This is probably one of the repositories I would recomm

This is a submission for Weekend Challenge: Dog Days Edition Dog Whisperer is an app that looks at a photo of your dog, figures out what it's probably feeling, and then actually says it out loud in a voice that matches the mood. Grumpy dog gets a grumpy voice. Dramatically offended dog gets... a dramatically offended voice. You get the idea. It also doubles as a pet log — meals, weight, and walks tracked over time in Snowflake, with trend charts so you can actually see if your dog's been eating more than usual or losing weight. Add your pets and start logging. Use your unique username to keep track of your pets! Here is App in action: https://dogwhisperer-whi6rye8zklcdtnedyxmww.streamlit.app/ Demo Code Kaku-g / dog_whisperer How I Built It I used Google's Gemini (model: gemini-3.5-flash-lite ) to infer the mood of the dog (or cat, lizard, ferret — whoever's in the photo) from a single image, then passed that straight into Gemini's native TTS (model: gemini-3.1-flash-tts-preview ) to give it a voice that actually matches the mood — a sleepy dog sounds sleepy, a dramatic one sounds dramatic. For logging and trends, I used Snowflake — compute, databases, and tables — to store meals, weight, and walks for every pet and power the trend charts in the app. So it's really two things working hand in hand: a generative AI pipeline paired with a data warehouse. The AI part is what makes the app fun — inferring your pet's mood and giving it a voice. The Snowflake part is what gives it a real use case , since it's something you could keep using for long. Prize Categories I used Google AI and Snowflake, so I'm submitting under both: 🏆 Best Use of Google AI 🏆 Best Use of Snowflake

This is a submission for Weekend Challenge: Dog Days Edition What I Built PawID & Care is an enterprise-grade, multi-role emergency response and biometric identification platform built for community animal welfare and stray management. Operating as a "112-for-dogs" system, the platform bridges cutting-edge artificial intelligence, distributed ledgers, enterprise analytics, and autonomous voice agents into a single unified workflow. The core goal is to solve the fragmentation in animal rescue: pet owners lose dogs, street animal injuries go unreported, and cities lack real-time community health tracking. PawID & Care provides instant biometric triage, role-based portals for Owners, Rescuers, and Vets, and real-time emergency voice dispatching. Demo 📹 Watch the Demo Video: https://youtu.be/_B-2dL2fDX4 Code GitHub Repository: [ https://github.com/GamersStop/paw-id-care ] bash # Clone the repository git clone [https://github.com/GamersStop/paw-id-care](https://github.com/GamersStop/paw-id-care) # Install dependencies npm install # Start the server npm start

A fourth party is pursuing legal action against xAI, alleging that Grok was used to create CSAM based on her childhood photos.

OpenAI joins PORTS-Pike project, expanding community investment and supporting thousands of Southern Ohio jobs

"our work got checked by an external reviewer." That's what Fable said after I brought Gemini...

A delete button is easy to ship. Real deletion is much harder. That gap matters more with AI agents than with normal apps because one user action can scatter data across prompts, traces, memory stores, vector indexes, tool logs, temporary files, model gateways, retry queues, and analytics events. If your product only deletes the visible chat row, the user may be gone from the UI while their data still lives in five backend systems. For AI app builders, this is not just a compliance chore. It is a trust feature. Users will forgive slow answers faster than they forgive a system that says “deleted” but keeps enough context to reconstruct the conversation later. This guide shows how to design an AI agent data deletion pipeline that removes user data for real, proves what happened, and avoids breaking production workflows while doing it. Why AI deletion is different Traditional deletion usually starts with a known record: a user, a project, a file, a message, or a row in a database. AI agents create a messier shape. A single agent run may include: raw user prompt rewritten prompt retrieved documents embeddings cached model input tool arguments tool responses browser snapshots screenshots uploaded files generated artifacts chain-of-thought-like internal notes you should not store memory summaries trace logs billing metadata support debug events queue state approval comments eval replay packets Some of those records are user-visible. Many are not. That is why “delete the chat” is not enough. Agent deletion needs a map of every place where user data can land, plus a workflow that deletes, redacts, or tombstones each location according to its risk and legal retention rules. The failure mode: UI deletion without backend deletion The dangerous pattern looks like this: The user clicks delete. The app removes the conversation from the sidebar. The backend keeps traces, embeddings, prompts, and tool logs for debugging. A restored pointer, support export, analytics query, or vecto

During a routine morning triage of my open-source project, git status showed a modified file I had no memory of touching: extension/background.js , last modified 24 hours earlier, sitting next to a fresh background.js.bak someone had thoughtfully left behind. Nobody broke in. I run several AI coding sessions in parallel against the same machine, and one of them — working on a completely different task, automating a GoHighLevel workflow — had hit a limitation in my browser automation tool, fixed the tool itself , verified the fix, and then moved on with its actual job. It never committed. It never told anyone. It just left better code in my working tree and walked away. The diff was good. That was the problem. The change itself was a real feature. My query_all tool (it queries DOM elements across a page) stopped at the main frame: if the elements you wanted lived inside a cross-origin iframe, you got back a clean, confident, empty array. The uncommitted diff added an execAcrossFrames() helper that runs the query in every frame and merges the results, plus x / y / frame fields on each returned element. I verified it the way you'd verify anything: syntax check passed, and the full test suite — all 82 tests — ran green with the change in place . So: useful feature, my own repository, every signal green. Everything about the situation said commit it . I didn't. I wrote it up in my project log, left the file untouched, and set an explicit deadline: if it's still sitting there uncommitted in three days, evaluate it properly — upstream it or revert it and file an issue. Not "leave it and see," which is how working trees rot. A quarantine with no release date is just a junk drawer. Why quarantine green code? Two reasons, and neither is paranoia. First: authorship isn't verification. The session that wrote this code had context I didn't have. Maybe it was mid-iteration and the diff was half of a plan. Maybe the .bak file meant it intended to roll back. Committing someone's wo

The page says that a property manager never received a welcome email. The useful signal should have arrived earlier, when that tenant's sending domain or delivery-event polling stopped matching the expected state. Short answer: keep welcome-email templates in the application when review history and portability matter most; use provider-owned templates when authorized non-engineers need to edit and preview copy, then select a transactional email provider that supports your chosen ownership model, per-domain management, and occasional batch sends. For a multi-tenant property SaaS, don't let the provider choose the template owner by accident. The reliable design is small: one authoritative template, one tenant-to-domain mapping, and one delivery ledger keyed by an application-generated message ID. Provider selection comes after those decisions. This ordering matters because a successful API request cannot prove that the correct branded message reached the correct property manager. Ownership comes first. How should multi-tenant SaaS welcome email templates be owned? Start with the people allowed to change the welcome message. Application-owned templates put markup, variables, tests, and review history beside the workflow that creates a manager account. They fit when a copy change must ship with a schema change, security-sensitive wording requires code review, or provider portability is a firm requirement. The catch is that a typo correction joins the engineering release path, and the team must build or adopt its own preview step. Provider-owned templates invert that arrangement. A lifecycle or support team can edit copy inside a controlled delivery workflow, and template preview lets a junior developer inspect the branded result before activation. Template identifiers and variable contracts then become deployed configuration. Rollback means selecting a known template revision, not merely reverting application code. I'm not sure which ownership model fits your organizati

OpenAI funds 14 independent projects exploring new AI policy ideas to expand economic opportunity and strengthen societal resilience in the Intelligence Age.

This is a submission for Weekend Challenge: Dog Days Edition I built Caninography, a small digital archive for exploring dog breeds from around the world. I wanted it to feel more like a digital museum than a normal dog website. You can explore breeds, their origins, history, countries, characteristics and connections between them. The whole design is dark, clean and visual. I also kept it silent, so there is no distracting audio or player UI. Live Demo: canonigraphy.vercel.app GitHub: https://github.com/maisamabbas0323/canonigraphy.git How I Built It I built it with React, Vite and TypeScript. For the visual side, I focused a lot on typography, photography, smooth transitions and responsive layouts. I also added an interactive world atlas and a constellation-style view to explore breed relationships. For the content, I used Google Gemini to help create short and interesting breed information. I didn't wanted to make another chatbot. Instead, Gemini stays behind the experience and helps make the archive content more rich while people simply explore it. Prize Categories Best Use of Google AI Caninography is submitted for Best Use of Google AI. I used Google Gemini to generate concise, breed-specific information based on the archive data. The idea was to use AI in the background, not put a chatbot in front of the user. Built With React Vite TypeScript Google Gemini CSS SVG Canvas A Little About The Idea I always felt dog breed information is mostly shown as simple lists. So I thought: What if a dog archive felt like a museum? That small idea became Caninography. A place to explore their stories, origins and history — one breed at a time.

This week, Anthropic's system-prompt release notes became the top story on Hacker News. The page is where Anthropic publishes the exact instructions that steer Claude on claude.ai and its mobile apps. It hit more than 550 points and 230 comments within a day, and the discussion is still going. The most interesting thing about the page is not any single rule. It is the size. Claude Opus 3's system prompt, dated July 12, 2024, is 358 words by my count. Claude Opus 5's, dated July 24, 2026, is 3,235 words. Nine times larger in two years. I have been building production AI systems with Spring Boot and Spring AI for over a year, and I run my own agent infrastructure. When the prompt that controls a frontier model grows ninefold, that is not an Anthropic curiosity. It is a warning and a playbook for every team shipping an AI product. Here is what is actually inside those 3,235 words, and what production teams should copy from them. What Anthropic actually published The release notes ( platform.claude.com/docs/en/release-notes/system-prompts ) are a changelog of system prompts for the consumer chat products. Two details on the page matter: These are not the API prompts. The page says claude.ai and the mobile apps "use a system prompt to provide up-to-date information, such as the current date, to Claude at the start of every conversation," and that "these system prompt updates do not apply to the Claude API." Models are now fixed snapshots. Since the Claude 4.6 generation, "each model ID is a single fixed snapshot," so each model has exactly one entry in the changelog. Simon Willison turned the page into a git repository ( github.com/simonw/research ) containing 29 prompt revisions across 17 models, each committed with the date from the source document. That means you can run git diff between any two versions of Claude's personality. It is a remarkable thing: the product spec of a frontier model, versioned like source code, and public. What the 3,235 words actually contain

Fixing "g++ Not Found" When Debugging Rails in RubyMine on Fedora TL;DR: If clicking "Debug" in RubyMine on Fedora fails to install debase because of a missing g++ compiler, the standard @development-tools group might not be enough. Run sudo dnf install gcc-c++ make redhat-rpm-config to get the explicit C++ compiler and tools Ruby needs to build native extensions. I was recently working on a Rails app on my Fedora machine and wanted to step through some code. I fired up RubyMine, set my breakpoints, and clicked the "Debug" button, fully expecting everything to just work. Instead, RubyMine tried to automatically install the debase and ruby-debug-ide gems—which it needs under the hood to hook into the Ruby process—and threw a massive wall of error text at me. The core of the failure looked like this: Building native extensions. This could take a while ... ERROR: Error installing debase-3.0.17.gem: ERROR: Failed to build gem native extension. ... /path/to/extconf_common.rb:80:in 'Kernel#`' : No such file or directory - g++ ( Errno::ENOENT ) My system was essentially complaining that it couldn't find g++ , the C++ compiler. The Initial (Failed) Attempt My first thought was, "Oh, I must have forgotten to install the base build tools on this machine." Since I'm on Fedora, I reached for the standard DNF command to pull in the development group: sudo dnf install @development-tools (Note: If you're on older versions of Fedora, you might be used to dnf groupinstall "Development Tools" , but DNF5 uses the @ syntax or space-separated group install ). It downloaded and installed a bunch of packages. I felt confident, went back to RubyMine, clicked "Debug" again, and... got the exact same No such file or directory - g++ error. Why Didn't That Work? When you install Ruby gems that contain native C or C++ extensions (like debase ), Ruby doesn't just download a pre-built binary. It actually compiles the raw source code down to machine code directly on your machine so it runs as fast

Hook: Imagine being able to set up rate limiting for your LLM APIs in MuleSoft—something that typically requires complex code—simply with just three clicks. No need to dive deep into Java or XML; it’s as simple as configuring a few settings on Anypoint. Demystifying Rate Limiting: Your Path to Controlled API Usage If you're a citizen developer or business analyst navigating the world of no-code/low-code automation, one common challenge is managing your LLM API usage without overwhelming your monthly budget. Tools like MuleSoft often present rigid pre-built connectors and complex data mapping transformations that can be daunting if you’re not well-versed in XML or Java. But fear not! The process doesn’t have to be as complicated as it seems. Let’s take a look at how Anypoint simplifies the implementation of rate limiting, allowing your client applications to use LLM APIs responsibly and without breaking the bank. Step 1: Setting Up Token Bucket Policy First, you'll want to set up a token-bucket policy on Anypoint that caps per-client spend. This is where MuleSoft’s flexibility shines through its intuitive interface: Navigate to Your API Gateway: Log in to your Anypoint Platform and select the API Gateway. Choose Rate Limiting Policy: In the policies section, choose 'Rate Limiting'. Configure Token Bucket Settings: Set up a token bucket policy where you define how many tokens (requests) are allowed within a given time frame. This straightforward setup prevents any single client from overusing LLM resources, ensuring fair and sustainable usage across all your applications. Step 2: Handling Excess Requests with Grace Now, what happens when a client exceeds their allocated limit? The magic of MuleSoft lies in its ability to handle these scenarios gracefully: Automated 429 Responses: When the rate limit is exceeded, Anypoint automatically returns a 429 status code (Too Many Requests). This clear response tells the client application that it needs to slow down. Retry-After

We started building OliverGraph to give teams and their AI agents shared context across GitHub, Slack, docs, and the other places where work happens. At first, we thought the main problem was retrieval. Company knowledge is scattered across GitHub, Slack, docs, tickets, and people so we could connect those systems and get the right context to the agent when needed. But we ran into another problem. Agent runs were becoming another place where important context lived. An agent also gets context directly from the engineer using it. An engineer might tell an agent that the team tried something before, that a customer depends on a certain behavior, or that there's a constraint that isn't documented anywhere else. The agent uses that context while doing the work, but when the run ends, it can disappear with it. The next engineer's agent may see the resulting code without knowing what context was given to the previous agent. This gets messier during outages. Several engineers might be investigating at once with their own agents. One agent rules out a recent deploy while another discovers an issue with a database query. Those findings are now spread across separate agent sessions, and another agent might spend time investigating something that was already ruled out. Humans already deal with this Companies have fragmented context. One engineer remembers an old outage and another engineer remembers that the team already tried an approach but abandoned it. So we ask each other. Who worked on this? Why is this here? Didn’t we try this already? You might not know the answer, but you know John worked on that part of the system. John remembers the PR and the PR points to an incident. People slowly build a mental map of where all that context lives in the company. Agents don’t have that. As everyone starts using more agents, it becomes harder for humans too. My agent may be changing onboarding while your agent is modifying authentication. Another teammate’s agent may have just disc

This is a submission for Weekend Challenge: Dog Days Edition What I Built PawSafe is an AI-powered web application that helps dog owners answer a simple but important question: "Can my dog eat this?" Users can enter the name of a food, upload a photo, or provide both. PawSafe then analyzes the information using Google's Gemini API and provides a simple safety assessment. The result is categorized into four levels: 🟢 Generally Safe 🟡 Use Caution 🔴 Not Safe ⚪ Unable to Determine Along with the result, PawSafe provides explanations, potential warnings, and safer alternatives when appropriate. My goal was to build something that was useful, simple to understand, and approachable for dog owners rather than making users search through multiple sources every time they encounter an unfamiliar food. Demo Live Demo Code GitHub Repository How I Built It PawSafe is a full-stack application built with: Frontend React Vite Tailwind CSS Lucide React Backend Node.js Express Multer CORS Google Gemini API Deployment Render GitHub The basic flow looks like this: User ↓ Food name / Image / Both ↓ React Frontend ↓ Express API ↓ Google Gemini ↓ Structured Analysis ↓ PawSafe Result Card One of the main technical decisions I made was to keep the Gemini API integration on the backend rather than exposing the API key in the frontend. The frontend sends the user's food information to the Express API. The backend then communicates with Gemini and returns the structured analysis to the frontend. I also wanted the application to support both text and images independently, while still allowing users to provide both when additional context is useful. Prize Categories Best Use of Google AI PawSafe is submitted for the Best Use of Google AI prize category. Google's Gemini API is the core intelligence behind the application. It is used to analyze both text-based and image-based food information and generate a structured safety assessment. The AI response is then presented through PawSafe's interface

We’ve all been there: staring at a delicious plate of pasta, trying to figure out if it's 400 or 800 calories. Manual tracking is a chore, and standard apps often fail at portion estimation. But what if we could combine Computer Vision , Multimodal LLMs , and Vector Databases to build an automated nutritionist? In this tutorial, we are building a state-of-the-art Multimodal Food Estimation Pipeline . By leveraging the Segment Anything Model (SAM) for precise boundary detection and GPT-4o Vision for contextual analysis, we can bridge the gap between "looking at a photo" and "calculating nutritional density." Whether you're interested in AI-driven wellness , FastAPI development , or Multimodal RAG , this guide covers the full stack. The Architecture 🏗️ The pipeline follows a sophisticated "Identify -> Analyze -> Match" flow. We don't just ask GPT-4o "what is this?"; we use SAM to isolate food items first to ensure the LLM focuses on the right pixels. graph TD A[User Uploads Image] --> B{SAM Model} B -->|Segmentation| C[Isolated Food Patches] C --> D[GPT-4o Vision API] D -->|Item + Volume Est.| E[Embedding Generation] E --> F[PostgreSQL + pgvector] F -->|RAG Retrieval| G[Verified Nutritional Data] G --> H[Final Response: Calories & Macros] Prerequisites 🛠️ Before we dive in, make sure you have the following ready: Python 3.10+ OpenAI API Key (for GPT-4o) PyTorch (for SAM) PostgreSQL with the pgvector extension enabled FastAPI for the backend Step 1: Precise Segmentation with SAM 🎯 The biggest challenge in food AI is overlapping items. Using Meta’s Segment Anything Model (SAM) , we can extract the exact mask of a food item, which helps in calculating the relative "area" occupied on the plate. import torch from segment_anything import sam_model_registry , SamPredictor import cv2 # Load SAM model sam_checkpoint = " sam_vit_h_4b8939.pth " model_type = " vit_h " sam = sam_model_registry [ model_type ]( checkpoint = sam_checkpoint ) predictor = SamPredictor ( sam ) def get_f