The best of dev and AI, scored every day by an agent. Filtered, summarized, ranked. No color, no noise — just the substance.
Ce workshop pousse à des défis avancés : créer une boucle évaluatrice-optimisatrice et afficher les sources côté frontend. La logique actuelle revient à un simple if/else : si l’IA a assez d’information, elle répond ; sinon elle lance une recherche. L’objectif est d’adopter le motif évaluation-optimisation et d’afficher les sources comme des cartes dans l’interface.
This workshop demonstrates how to turn a quick chat prototype into a persistent product by adding backend persistence, streaming updates, and robust routing. It covers building a POST /api/chat endpoint to stream OpenAI completions, persisting chats with Drizzle and returning a chatId, routing to /chat/:chatId, saving messages in real time while rehydrating the UI from the database.
This workshop shows how to turn a quick Vercel AI SDK chat prototype into a durable, persistent product with backend persistence, real-time updates, and solid routing. You'll implement a POST /api/chat that streams completions with createDataStreamResponse, use Drizzle to create the chat and emit the chatId on the stream, save user and assistant messages as they arrive, and rehydrate the UI from stored conversations while keeping the sidebar in sync via route revalidation.
Day 3 montre comment observer et déboguer un agent IA en production grâce à l'observabilité et aux traces. Vous configurez Langfuse, explorez les premières traces et ajoutez des métadonnées de trace personnalisées, puis implémentez un outil de scraping temporel.
Observability is crucial for AI-driven products since responses can drift. Day 3 shows how to see, debug, and improve agents using Langfuse, traces, and custom metadata, and to build a time-aware web scraper tool.
Using Vercel AI SDK's useChat, this workshop guides turning a quick chat prototype into a persistent, streaming chat app. It covers streaming completions, creating/storing chat IDs, routing by chatId, and persisting messages in real time, plus rehydrating UI from the database and updating the sidebar via route revalidation. By the end you’ll have an end-to-end persistent chat experience with routing, saving, and reloading conversations.
Day 4 focuses on turning subjective agent vibes into objective, data-driven evaluation using LLM Evals. It introduces Evalite, an open-source eval framework built on Vitest to run tests without cloud providers, and guides you to define success criteria and write a first scorer to aim for a 100 score. By end, you'll have a foundational evaluation setup for the DeepSearch agent.
Dans ce workshop, on aborde des patterns avancés: une boucle évaluateur-optimiseur et l'affichage des sources côté frontend. L'agent devient une simple logique if-else et l'objectif est d'optimiser via une boucle d'évaluation, inspirée par Anthropic. On propose aussi d'afficher les sources sous forme de cartes dans l'UI pour plus de traçabilité.
This workshop examines how much control the LLM should have over the app's control flow, pitting agents against workflows. It notes that more agentic systems offer flexibility, while deterministic workflows improve predictability. In upcoming exercises, the dial will be turned back toward determinism to test concrete patterns.
Day 1 guides you through building a real AI agent in TypeScript, from wiring an LLM with the Vercel AI SDK to debugging tool calls and securing the app. It covers tool integration (Serper), authentication (Discord login), and rate limiting, showing every step, tool call, and source. By the end, you have a working agent that chats, searches, and transparently explains its work.
Observability is crucial for AI-driven products; Day 3 covers seeing, debugging, and improving agents. You'll set up Langfuse, explore traces, and add custom trace metadata, then build a time-aware web scraper tool. By the end, your DeepSearch agent becomes understandable and deployable with confidence.
Ce workshop transforme un prototype de chatbot en expérience persistante: persistance des messages en streaming, création d’un chatId et routage vers /chat/:chatId, sauvegarde en DB et réhydratation de l’UI. Vous verrez comment router, revalider le sidebar et recharger les conversations de manière fiable.
That workshop reframes the agent as an evaluator-optimizer loop: one LLM call generates a response while another provides evaluation and feedback. It also covers showing sources in the frontend with a card-like UI (favicon, title, snippet) to surface provenance and improve traceability.
Day 3 focuses on observability for AI agents. It guides you to set up Langfuse, inspect traces, and add custom trace metadata to diagnose and improve your DeepSearch agent. By the end, you'll transform it from a mystery into a well-understood, diagnosable system.
In this workshop you'll tackle advanced challenges: an evaluator-optimizer loop and showing sources in the frontend. The description frames the system as an evaluator in a loop and proposes frontend source cards—favicon, title and snippet—similar to patterns in Anthropic's Building Effective Agents.
Utiliser useChat de Vercel AI SDK permet de lancer rapidement un chatbot. Cette session montre comment transformer un prototype en chat persistant: endpoint POST /api/chat, enregistrement des messages avec Drizzle, routing par chatId et réhydratation de l’UI à partir de l’historique stocké. Vous obtiendrez une expérience end-to-end avec streaming, sauvegarde et rechargement des conversations.
Observability is essential when building AI-driven products. Day 3 teaches you to see and debug agent behavior using Langfuse, explore traces, and add custom trace metadata, then to build a time-aware web scraper tool to improve your DeepSearch agent.
This workshop demonstrates turning a quick prototype with the Vercel AI SDK into a durable, persistent chat app. It covers streaming completions via a POST /api/chat endpoint, using Drizzle to create and return a chatId, saving messages as they stream, and rehydrating the UI while routing by chatId for seamless reloads.
This workshop reframes the typical LLM agent as an evaluator-optimizer loop: one call generates a response while another evaluates it, then feedback guides the next step. It emphasizes moving logic from a pure agent to an evaluative loop and optimizes around it. It also covers displaying sources in the frontend as card-like items (favicon, title, snippet) to mirror DeepResearch patterns.
Observability is essential when building AI-driven products, enabling you to see, debug, and improve agent behavior as conversations and calls grow. Day 3 guides you through setting up Langfuse, exploring traces with custom metadata, and building a time-aware web scraper tool to turn the DeepSearch agent into a well-understood system.