All Tags

Tag

ai-agents

10 items tagged with "ai-agents"

Course

AI Hero: 7-Day AI Agents Crash-Course

Build a complete AI agent from data ingestion to deployment in 7 focused days. You will use a real GitHub repository as the source material, then build an assistant that can read the project, search through its docs and code, answer questions with citations, and ship as a small web app. This is not a toy chatbot course. By the end, you will have a portfolio-ready AI project with code, evaluation, a demo, and a clear README. What your agent will be able to do Your agent will understand a real codebase, not a tiny example file. You can use your own repository, or choose an open-source project if you do not have one ready. During the course, you will build an assistant that can: Read documentation, code, issues, and comments from a GitHub repository Split large files into useful chunks for retrieval Search with lexical search, semantic search, and hybrid search Answer project-specific questions using RAG Use tools and function calling for more useful responses Keep answers grounded with citations and logs Evaluate the quality of search and agent responses Run behind a simple Streamlit interface Be shared as a portfolio project Example question: How does authentication work in this project? By the end of the course, your agent should be able to answer questions like this by looking at the project files it indexed and pointing you to the relevant parts of the codebase. What you need Plan for 1-2 hours per day. The lessons are practical and build on each other, so it is better to do a little every day than to read everything at once. You will need: Basic Python skills: functions, classes, virtual environments, and pip Comfort with the command line A GitHub repository to analyze, or an open-source repository you want to study An OpenAI API key for the hands-on exercises A laptop where you can run Python locally The OpenAI API cost for the course is usually small. For most projects, expect a few euros or dollars, depending on the size of the repository and how much you experiment. What you will build in 7 days Each day adds one piece to the same project. Day 1: ingest and index your data from GitHub Day 2: chunk and prepare the data for search Day 3: add lexical, semantic, and hybrid search Day 4: turn the search system into an agent with tools Day 5: add logging, citations, and evaluations Day 6: publish the agent with a Streamlit UI Day 7: write the README, record a demo, and share the result Certificate: submit the finished project and get the completion certificate The syllabus below contains the detailed lessons and homework for each day. What you will have at the end When you finish, you will have a working AI assistant that understands a GitHub project and can answer questions about it. You will also have the supporting pieces that make it useful outside a notebook: Source code you can keep extending A documented ingestion and search pipeline An agent with tools and prompts Evaluation data and checks A deployed web interface A README with screenshots or a demo video A certificate of completion after project submission The goal is to leave with something you can show: in a portfolio, in a job conversation, or as a base for your next AI engineering project. Frequently asked questions What makes this different from other AI tutorials? You build with a real GitHub project, not a generic demo. The course connects the full path from data ingestion to search, agent behavior, evaluation, deployment, and portfolio packaging. What if I do not have a GitHub project? Use an open-source project that interests you. The important part is learning with real code and real documentation. Do I need an OpenAI API key? Yes. The hands-on exercises use the OpenAI API. The course shows how to keep usage small while still building the full workflow. Can I do it on a phone or tablet? You can read the lessons anywhere, but you need a computer for the coding exercises. Why is it free? This course gives you a practical foundation and shows the teaching style we use at AI Shipping Labs. If you want more structure, feedback, and accountability after that, join the community and continue with sprints, workshops, and project reviews.

May 6, 2026
ai-agents rag python pydantic-ai evaluation
Event

From RAG to Agents: Implementing Agentic Search

We build a classic RAG system over real documentation, then evolve it into an agentic search workflow where the LLM decides what to search for and whether to open a full document. Along the way we implement two tools - search (returns highlighted snippets) and get_file (returns the full document) - and wire them into an agent using both toyaikit and PydanticAI. The knowledge base is the Evidently AI documentation: a real, evolving set of Markdown files that makes RAG genuinely useful, since LLMs can't keep up with library docs on their own. This workshop was originally delivered at DataMakersFest 2026 in Porto, Portugal. There is no recording available. The system you will build The architecture has one LLM agent with two tools and two data sources: flowchart LR USER["User"] AGENT["Agent (LLM)"] SEARCH["search tool<br/>highlighted snippets"] GETFILE["get_file tool<br/>full document"] MINSEARCH["minsearch index<br/>Evidently docs"] FILEINDEX["file_index<br/>filename -> content"] USER -->|question| AGENT AGENT -->|decides which tool| SEARCH AGENT -->|decides which tool| GETFILE SEARCH -->|query| MINSEARCH MINSEARCH -->|snippets| SEARCH GETFILE -->|filename| FILEINDEX FILEINDEX -->|full text| GETFILE SEARCH -->|results| AGENT GETFILE -->|results| AGENT AGENT -->|answer| USER The agent has two tools and decides which one to use. search returns short highlighted snippets so the agent can decide which documents are worth reading. get_file returns the full document so the agent can read it end-to-end. The pattern mirrors how humans read documentation: search, scan snippets, open the promising one. Links Resources not included in the workshop materials list: toyaikit - teaching framework for agents PydanticAI - production agent framework

May 4, 2026
rag ai-agents llm-engineering search tooling-architecture
Event

Build Your Own AI Coding Agent

We build a coding agent from scratch: tool calls, an agentic loop, a skills system that loads reusable instruction files on demand, and a final version running on PydanticAI. The agent can read and write files, run shell commands, search the codebase, and load specialized skills - all inside a structured Django project template. This workshop was originally delivered at MLCon 2026 Amsterdam. There is no video recording available. The agent you will build The architecture of the final agent: flowchart LR USER["User"] RUNNER["Runner<br/>ToyAIKit / OpenAI Responses"] LLM["LLM<br/>gpt-5.4-mini"] TOOLS["Tools<br/>read_file, write_file<br/>see_file_tree<br/>execute_bash_command<br/>search_in_files"] SKILL["SkillTool"] LOADER["SkillLoader"] SKILLS["SKILL.md files"] USER -->|prompt| RUNNER RUNNER -->|model call| LLM LLM -->|tool call or response| RUNNER RUNNER -->|execute tool| TOOLS RUNNER -->|load skill| SKILL SKILL --> LOADER LOADER -->|read| SKILLS RUNNER -->|answer| USER The agent runs inside a Django project template. It has five core tools for interacting with the filesystem and shell, plus a skills tool that loads extra instructions from SKILL.md files when the agent decides they are relevant. The workshop progresses through four parts: understanding tool calls, building the coding agent, adding skills, and porting to PydanticAI. Links Related workshops and resources: Previous coding-agent workshop - the v1 version without skills agent-skills workshop - the standalone skills workshop

Apr 21, 2026
ai-agents llm-engineering agent-systems tooling-architecture
Event

Skills.md from Scratch: Build a Skill-Driven Coding Agent

A newer, combined version of this workshop is available: Coding Agent with Skills. We start from the coding agent in the prerequisite workshop. We turn it into a general-purpose coding agent with two reusable behavior layers: skills and slash commands. The agent loads a skill when your request matches its description. You invoke a command with a leading slash, and the system renders it into a prompt before the agent acts. Links External resources for this workshop: Starting notebook GitHub fetch skill Prototype implementation Prerequisite coding-agent workshop ToyAIKit OpenCode OpenCode skills documentation AgentSkills spec The agent you will build By the end you'll have built a system that looks like this: flowchart LR USER["User"] RUNNER["ToyAIKit runner<br/>OpenAI Responses"] LLM["OpenAI model"] CODETOOLS["Coding tools<br/>read, write, tree, bash, search"] SKILLTOOL["skill(name) tool"] LOADER["SkillLoader"] SKILLS["skills/*/SKILL.md<br/>scripts and templates"] COMMANDS["commands/*.md"] COMMANDTOOL["execute_command(name, args)"] USER -->|plain request| RUNNER USER -->|/command| RUNNER RUNNER --> LLM RUNNER --> CODETOOLS RUNNER --> SKILLTOOL SKILLTOOL --> LOADER LOADER --> SKILLS RUNNER --> COMMANDTOOL COMMANDTOOL --> COMMANDS The project stays small enough to understand in a notebook, but it mirrors the pieces used by real coding agents. The coding tools let the model read, write, search, and run commands. The skill loader turns SKILL.md files with YAML frontmatter into tool-loadable instructions. The command loader turns markdown files like review.md or test.md into reusable prompt templates.

Jan 16, 2026
ai-agents llm-engineering agent-systems tooling-architecture
Event

Building Safe AI Agents with Guardrails

We start with a DataTalks.Club Data Engineering Zoomcamp FAQ assistant. Then we add checks that keep the agent on topic and block unsafe responses. The checks also show how to cancel wasted work when a guardrail fails. We first use the OpenAI Agents SDK for its built-in guardrails. Then we rebuild the same idea with tools and plain asyncio, so it works with other agent frameworks. Links The external resources: Related course: AI Bootcamp: From RAG to Agents FAQ data used by the agent AI Hero email course for the docs.py loader OpenAI Agents SDK guardrails documentation The notebook you will build By the end, you wrap a tool-using FAQ agent in guardrails: flowchart LR USER["User question"] INPUT["Input topic guardrail"] FAQ["FAQ assistant agent"] SEARCH["search_faq tool<br/>minsearch index"] OUTPUT["Output safety guardrail"] ANSWER["User-facing answer"] OPENAI["OpenAI model calls"] USER --> INPUT INPUT -->|passes| FAQ INPUT -->|trips| ANSWER FAQ --> SEARCH FAQ --> OPENAI INPUT --> OPENAI OUTPUT --> OPENAI FAQ --> OUTPUT OUTPUT -->|passes| ANSWER OUTPUT -->|trips| ANSWER The base agent can already search the FAQ, but it tries to answer unrelated questions too. The input guardrail blocks questions outside the course domain. The output guardrail checks the agent response for policy problems. Examples are promising deadline extensions or writing homework for a student. In the later parts we show the same checks as tools. We also build a small async runner that can cancel work when a guardrail trips.

Jan 6, 2026
ai-agents llm-engineering agent-safety tooling-architecture async-control
Event

Build a Production-Ready YouTube AI Agent with Temporal

We build a deep research agent over the DataTalks.Club podcast archive. We start by downloading and indexing YouTube transcripts. Then we turn that ingestion code into a durable Temporal workflow. Once the data is searchable, we build a Pydantic AI research agent. We add a summarization sub-agent for long transcripts and wrap the agent run in Temporal too. Links The main resources for this workshop: Temporal CLI install notes DataTalks.Club podcasts The system you will build The final system looks like this: flowchart LR YT["YouTube transcripts"] CACHE["Cached transcript files<br/>GitHub fallback"] FLOW["flow/<br/>Temporal ingestion"] ES["Elasticsearch<br/>podcasts index"] AGENT["agent/<br/>Pydantic AI research agent"] SUM["Summarization sub-agent"] TW["Temporal workflow<br/>agent run"] OPENAI["OpenAI"] YT -->|fetch_subtitles| FLOW CACHE -->|fetch_transcript_cached| FLOW FLOW -->|index_video| ES AGENT -->|search_videos| ES AGENT -->|summarize| SUM AGENT -->|model call| OPENAI SUM -->|model call| OPENAI TW -->|durable execution| AGENT The ingestion side has the parts that usually fail in production. It makes network calls, runs proxies around YouTube's cloud-IP blocks, and writes to Elasticsearch. It also loops over many videos. Temporal gives that side retries, observability, and durable execution. The agent side uses the indexed data to answer questions from the podcast archive. It uses Temporal again too, so long agent runs can survive failures.

Dec 16, 2025
ai-agents data-engineering temporal elasticsearch production-systems
Event

Build a Course FAQ Agent with MCP, PydanticAI and OpenAI

We build a course FAQ assistant from the bottom up. First we expose a plain Python search(query) function to the OpenAI Responses API. Then we turn the same idea into a reusable agent loop and compare toyaikit, OpenAI Agents SDK, and PydanticAI. Finally we move the FAQ tools behind an MCP server. From there a notebook, PydanticAI, Cursor, and VS Code can all reach them. Links The main resources: AI Bootcamp: From RAG to Agents Prerequisite workshop: Building a Coding Agent Data Engineering Zoomcamp FAQ source document Parsed FAQ JSON FAQ parsing notebook The system you will build The final setup looks like this: flowchart LR NOTEBOOK["Jupyter notebook"] OPENAI["OpenAI Responses API"] FRAMEWORKS["Agents SDK<br/>PydanticAI"] MCPCLIENT["MCP clients<br/>toyaikit, PydanticAI, Cursor"] MCPSERVER["FastMCP server<br/>SSE or stdio"] TOOLS["FAQ tools<br/>search, add_entry"] INDEX["minsearch index<br/>FAQ JSON"] NOTEBOOK -->|function calling| OPENAI NOTEBOOK --> FRAMEWORKS FRAMEWORKS -->|tool calls| TOOLS NOTEBOOK -->|MCP client| MCPCLIENT MCPCLIENT -->|MCP protocol| MCPSERVER MCPSERVER --> TOOLS TOOLS --> INDEX The FAQ data comes from the Data Engineering Zoomcamp FAQ. The first half of the workshop keeps the tools inside the notebook so you can see the agent loop directly. The second half moves the same tools into mcp_faq/, which makes them reusable by any MCP client.

Sep 1, 2025
ai-agents llm-engineering agent-systems tooling-architecture mcp rag
Event

Building a Coding Agent: Python/Django Edition

For a newer, combined take, see Coding Agent with Skills. We build a small project bootstrapper for Django, a coding agent that takes a plain-language app request and copies a working Django template. From there it reads and writes files through tools, iterating until the generated app runs. The first version uses the OpenAI Responses API through ToyAIKit. Then we try the same idea with OpenAI Agents SDK, PydanticAI, Anthropic, and Z.AI. Links The main resources: ToyAIKit Django template repo Todo app made with Z.AI Related course: AI Bootcamp: From RAG to Agents Related workshop: Hands-on with AI Agents and MCP The app you will build You chat with the coding agent in a notebook. It's backed by an LLM and a small set of filesystem tools. You give it a request like to-do list, and the agent edits a copied Django template and leaves you with a project you can run. flowchart LR USER["You<br/>short app request"] CHAT["Jupyter chat UI<br/>ToyAIKit"] RUNNER["Agent runner<br/>Responses API or framework"] TOOLS["AgentTools<br/>read, write, tree, grep, bash"] DJANGO["Copied Django template<br/>project folder"] LLM["LLM provider<br/>OpenAI, Anthropic, Z.AI"] USER -->|type request| CHAT CHAT --> RUNNER RUNNER -->|tool calls| TOOLS TOOLS -->|modify files| DJANGO RUNNER -->|messages and tools| LLM DJANGO -->|make run| USER Two screenshots show what the finished workshop output looks like. The first one shows the notebook chat after the agent plans and starts calling file tools: The second one shows one of the generated Django todo apps: Result The simplest version is intentionally small. It runs in Jupyter, uses local filesystem tools, and edits one copied Django project folder. That's enough to understand how larger coding agents work under the hood. The same four steps scale to any size of agent: Prepare a template. Expose the right tools. Give the model precise instructions. Iterate on the generated code.

Aug 14, 2025
ai-agents coding-agents django python llm-engineering
Event

AI Coding Tools Compared: ChatGPT, Claude, Copilot, Cursor, Lovable and AI Agents

We compare AI coding tools by asking each to help build the same small app, Snake in React. We compare the tools rather than ship one polished build. The walkthrough follows the tool categories, moving from chat applications to coding assistants and IDEs, then to project bootstrappers and agents. Links The main resources: Lovable Snake preview AI Dev Tools Zoomcamp AI Engineering Buildcamp RAG agents workshop LLM Zoomcamp The comparison The same app appears in several workflows: flowchart LR PROMPT["Prompt<br/>implement snake in react"] CHAT["Chat apps<br/>ChatGPT, Claude, DeepSeek, Ernie, Microsoft Copilot"] IDE["Coding assistants and IDEs<br/>Claude Code, GitHub Copilot, Cursor, Pear"] BOOT["Project bootstrappers<br/>Bolt, Lovable"] AGENTS["Agents<br/>tools, file access, computer use"] CHATAPP["Local app<br/>snake-chatgpt"] CLAUDEAPP["Local app<br/>snake-claude-code"] PREVIEW["Hosted app<br/>Lovable preview"] PROMPT --> CHAT CHAT --> CHATAPP IDE --> CLAUDEAPP BOOT --> PREVIEW AGENTS --> IDE AGENTS --> BOOT We build two Vite React projects. snake-chatgpt keeps the game in one component, so it shows what a chat app can produce from a short prompt. snake-claude-code splits the page shell from the game component. It adds a score and a start-and-restart flow, plus WASD controls and a walls-versus-pass-through mode.

Jul 21, 2025
ai-tools coding-assistants comparison developer-tools ai-agents