freeCodeCamp.org Video Summaries

A beginner-friendly, seven-part course covering vector databases from the ground up, starting with vectors and similarity measures and building up to indexing, storage, and semantic search. Along the way, you create real embeddings in a live demo and finish with a working project.

■ Vector Database Fundamentals
- What a vector database is, how the ingestion and retrieval pipeline works step by step
- Why keyword search falls short for unstructured data, plus use cases such as recommendation systems and NLP search

■ Vectors and Tokenization
- Vectors, dimensions, and the two main similarity measures: cosine similarity and Euclidean distance
- Tokenization types: character-level, word-level, and subword tokenizers used by modern language models

■ Embedding Models and Live Demo
- Word, text, and multimodal embedding models, including Gemini embedding 001 and Gemini Embedding 2
- Notebook walkthrough: generating 768-dimension embeddings with Gemini, building a cosine similarity matrix, and visualizing sentences with PCA

■ Internals and Practical Project
- Architecture layers: API gateway, indexing (IVF and HNSW), storage, and query processing
- Storing embeddings in Chroma DB and running semantic search queries

Aimed at software, AI, and machine learning engineers with no prior knowledge required, the course leaves you able to explain how vector databases store, index, and retrieve high-dimensional embeddings and to apply semantic search yourself. Start with the fundamentals lectures, follow along with the notebook demos, and build the Chroma project to practice the full workflow.

Cyber security instructor Declan Middleton walks through a practical ethical hacking crash course, starting from core Linux fundamentals and progressing to network scanning, web enumeration and HTTP request interception. Everything is demonstrated safely and legally inside a local CTF lab using Parrot OS and an intentionally vulnerable VulnHub machine called Explorer.

■ Linux Fundamentals
- Terminal basics: ls, cd, pwd, mkdir, rm, cat, echo, cp, mv, nano/micro, file, du, find
- System and network: history, man, grep, ifconfig, ip a, ping, netdiscover, uname, hostname
- Privileges and users: sudo, adduser, passwd, usermod, deluser, chmod 755
■ Hacking Toolchain
- Nmap: basic scans, -sV, -sC, -A, -p-, -sS stealth, decoys and saving output with -oN
- Web enumeration: WhatWeb, curl, Gobuster, ffuf directory and subdomain fuzzing, Nikto
- Burp Suite: proxy interception, request analysis and the Repeater tab
■ Lab Setup and Automation
- Installing Parrot OS and the Explorer machine in VirtualBox, /etc/hosts configuration
- Bash scripting for automated recon, plus mentions of Python, Searchsploit, Wappalyzer and ProxyChains

This is suited to beginners and aspiring penetration testers who want to move from theory to hands-on practice in a legal lab environment. By following along you will gain working command line skills, understand how each tool fits into a penetration test workflow, and build your own simple recon automation.

Learn how to build Jev-style decision-making models from scratch using PyTorch and Hugging Face, replacing token-by-token decoding with a single forward pass to yield predictable outputs such as choices, ordinal scores, and boolean values. The session covers inference principles from the ground up and works toward the RLCD training workflow, using pre-trained models as a foundation.

■ Jev Fundamentals
- Choice, score, and null interfaces, and how a single forward pass differs from traditional decoding
- Traditional LLM inference walkthrough: prefill, decode, and step-by-step JSON generation
■ Implementations
- Encoder-only approach: question-first encoding, mask tokens, and query-option interaction
- Decoder-only approach: causal masking, KV cache reuse, and packing multiple questions
- Encoder vs. decoder trade-offs and guidance on when to choose each
■ Training with RLCD
- Loss design combining cross-entropy with RL components, GRPO-based advantage computation, and training options

Aimed at viewers already comfortable with attention, KV cache, logits, softmax, and PyTorch, the session is inference-focused and does not require a GPU. It provides an intuition for how these models work and a starting template you can adapt to your own use case.

A step-by-step JavaScript walkthrough demonstrates how to use Google Gemini 4 Argon through the official Google Gen AI SDK, from API key and billing setup to a background job that generates a playable Breakout game.

■ Model and setup
- Overview of Gemini 4 Argon, its model ID, thinking-before-answering behavior, large context window, and background execution
- API key creation in Google API Studio, billing activation, project setup with npm, the @google/genai package, and an environment file

■ Core API usage
- Sending a first request with client.interactions.create and reading output text
- Comparing low and high thinking levels on a small debugging example, including time and thinking-token usage
- Maintaining a conversation by passing a previous interaction ID
- Using background mode with high thinking and a raised output-token limit to generate an HTML Breakout game

■ Developer perspective
- A Google engineer discusses the model’s reasoning, 3D and creative-writing use cases, and an example built with Blender MCP and Nano Banana

Designed for beginners who can write basic JavaScript functions and want a practical introduction to the Gemini API. Viewers should leave with a clearer understanding of how to configure the SDK and experiment with thinking levels, conversation state, and background tasks in their own projects.

This MCP security course explains the Model Context Protocol, how MCP-enabled agents connect to external systems, and why those connections create new security risks. It presents a structured way to analyze agent risk using the lethal trifecta and walks through the OWASP MCP Top 10 with real-world examples, detection guidance, and remediation practices.

■ MCP foundations and architecture
- Host, client, server, and backend roles
- Request flow and trust boundaries across MCP interactions
- Why MCP changes how APIs are consumed by agents

■ Risk analysis model
- Private data, untrusted content, and external communications
- A practical scorecard for evaluating tools available to an agent

■ OWASP MCP Top 10 walkthrough
- Token mismanagement, privilege escalation, tool poisoning, supply chain risk, and command injection
- Intent flow subversion, authentication and authorization gaps, audit and telemetry gaps, shadow MCP servers, and context injection or oversharing
- Real incidents and scenarios used to illustrate each risk category
- Detection signals and remediation controls for each risk

■ Operational takeaways
- Monday-morning actions such as moving secrets to a vault, pinning and signing tool schemas, inventorying MCP servers, and logging tool calls
- Structural defenses that break one leg of the lethal trifecta

This course is aimed at developers, security engineers, architects, and platform teams working with AI agents and MCP integrations. Viewers can expect to leave with a clearer risk model for MCP deployments and concrete actions for improving visibility, access control, and incident readiness.

This tutorial demonstrates building a Wikipedia search application that combines keyword and semantic retrieval inside PostgreSQL. It uses real Simple English Wikipedia articles, SQL examples, and a simple web interface to compare PostgreSQL full-text search, PG Text Search BM25 ranking, pgvector semantic search, and hybrid rank fusion.

■ Setup and data loading
- Creating a Tiger Cloud PostgreSQL service and enabling PG Text Search, pgvector, and pgvector scale
- Loading about 242,000 Simple English Wikipedia articles and preparing a roughly 25,000-article embedding subset

■ Search methods
- PostgreSQL built-in full-text search with tsvector/tsquery, GIN indexes, ts_rank, and query plans
- PG Text Search BM25 scoring, index configuration, and ranked retrieval
- Semantic search with local embeddings stored in pgvector and approximate vector indexes
- Hybrid search using reciprocal rank fusion and adjustable semantic weighting

■ Application integration
- FastAPI endpoints, parameterized SQL, connection pooling, highlighted previews, and demo article insertion
- Operational considerations such as index building, performance measurement, and coverage limits

It is aimed at developers with SQL basics and enough Python to run scripts who want a practical comparison of PostgreSQL-native search techniques. Viewers gain a working mental model of keyword, semantic, and hybrid retrieval and can repeat the examples with their own data; the repository and README provide next steps.

This free course, From Watts to Tokens, explains what it takes to make an AI data center work by following electricity from the grid to GPUs and heat back outside. It focuses on the power, cooling, and data paths that turn raw megawatts into generated tokens.

■ Fundamentals and Electrical Primer
- Circuit basics, Ohm's law, heat loss, power, energy units, AC vs DC, three-phase power, power factor, transformers, rectifiers, inverters, UPS systems, and redundancy
- Data center naming, power sources, transmission, substations, generators, and rack-level power distribution

■ Compute, Networking, and Cooling
- Rack hierarchy, GPUs, memory, KV cache, model loading, and network speed
- Scale-up and scale-out domains, optical circuit switches, liquid cooling loops, CDUs, and PUE
- Workloads: training vs inference, prefill and decode, batching, interactivity, throughput, latency, and power variability

■ Real-World Application
- Construction, operations, economics, and the Abilene/Stargate site for OpenAI in Texas

It is intended for viewers with basic arithmetic and graph-reading skills who want a structured overview of AI data center infrastructure. The course includes slides, written explanations, and a glossary, and uses case studies to show why adding more GPUs or electrical capacity does not automatically yield more usable compute. Viewers can use it to build vocabulary and a mental model of power, cooling, and networking paths before exploring specialized topics further.

I explain a repeatable approach to clarifying requirements, structuring a design discussion, and communicating technical trade-offs in system design interviews. The guide applies that approach to music streaming and hotel reservations, with attention to capacity, data models, architecture, scaling, and reliability.

■ Interview framework
- Evaluation dimensions and a five-step process for organizing a 45–60-minute discussion
■ Music streaming platform
- Spotify-style requirements, capacity estimates, APIs, storage, architecture, and scaling
■ Hotel reservation system
- Booking flows, data models, search, concurrency, double-booking prevention, and reliability

Designed for engineers preparing for mid-level and senior interviews or building their system design fundamentals. Use the framework to practice a design, state your assumptions, and explain the trade-offs; the examples focus on these two systems rather than covering every system design topic.

Rahul Joshi explains how to use n8n to connect apps, APIs, and AI models in practical automated workflows. Through examples, the guide moves from core workflow concepts to reliability practices for systems used in production.

■ n8n foundations and integrations
- Workflow design, triggers, webhooks, HTTP requests, API data handling, and self-hosting
■ AI workflows and agents
- Structured document analysis, web research, chatbots, Google Sheets knowledge and memory, and multi-agent content workflows
■ Production patterns
- Event-driven lead qualification, human approval, error handling, monitoring, execution metrics, and token tracking

For developers and no-code automation builders, the material provides examples to adapt and a framework for planning workflows. Start by identifying a repetitive process, then apply the relevant trigger, data, decision, and monitoring patterns; deployment details vary by service and infrastructure.

I walk through the core concepts of TanStack Router by building a meetup-tracking application, from route setup to data-driven pages. The examples show how routing can manage navigation, loading, search filters, and protected pages in a TypeScript React app.

■ Foundations and navigation
- Route trees, root layouts, file-based routes, links, programmatic navigation, and lazy routes
■ Data and application behavior
- Loaders, loading and error states, dynamic meetup details, and URL search filters validated with Zod
- Router context, authentication checks, form mutations, cache invalidation, and route debugging
■ Comparisons and scope
- A closing comparison with React Router and Next.js; TanStack DevTools and deeper Zod instruction are not covered in depth

This walkthrough is aimed at React developers who want to build or evaluate a type-safe routing setup. Follow along by creating the starter project, then adapt the meetup routes, filters, and authentication flow to a small application of your own.

I explain how to build and train a 25-million-parameter GLM-style model on standard hardware, covering pretraining, vision components, and reinforcement learning. The examples also show how to frame research questions and evaluate controlled experiments; the focus is a small learning setup, not training a frontier-scale model.

- Model foundations: tokenization, transformer components, linear and sparse attention, and mixture-of-experts
- Training: language-model pretraining, a small vision example, and reinforcement-learning workflows
- Research practice: reward design, evaluation environments, experimental variables, and statistical considerations

Designed for learners and aspiring AI researchers, this walkthrough offers a practical starting point for studying model training and experimental design. Review the accompanying code, then try small experiments that vary one factor at a time and assess their results carefully.

I walk through a practical workflow for turning an app idea into an Instagram-style social app, using AI for planning, interface design, and implementation. The example covers authentication, social features, a real-time backend, and testing on a phone, while the supplied portion does not show a completed App Store submission.

■ Project planning and design
- Define features and user flows with an AI planning prompt; create UI references and iterate on screens.
- Set up an Expo project and build its authentication and main screens.
■ Implementation and testing
- Connect Clerk authentication and Convex for data, media, posts, likes, comments, follows, and messaging.
- Add sample content, review code with CodeRabbit, and create an EAS development build for phone testing.
■ Publishing considerations
- Discuss privacy policies, terms of service, account deletion, and Apple developer enrollment; deployment itself is not covered in the provided section.

For developers and beginners exploring AI-assisted app creation, this walkthrough offers a repeatable sequence to try: plan a small first release, build screen by screen, and test it on a device. You’ll see how the example’s tools fit together and which publishing requirements to consider before submission.

I build a momentum-based paper-trading application in Python, connecting Massive market data, SnapTrade brokerage linking, and Alpaca paper trading. The walkthrough covers setup through a working Django interface, with practical examples of database models, API integrations, and troubleshooting.

■ Account and project setup
- Create service accounts, configure credentials, and establish a Django project
■ Data and strategy implementation
- Model stocks, prices, portfolios, and trades; retrieve market data and calculate 12-month momentum
■ Application and paper-trading workflow
- Build dashboard and trading views, connect a simulated brokerage account, and test generated trade signals
■ Scope
- Focuses on a 50-stock universe and paper trading; backtesting is left as a placeholder, and live-money trading is not demonstrated

For Python developers and learners exploring algorithmic trading, this provides a step-by-step reference for building and testing a paper-trading workflow. Follow along by setting up the required accounts and credentials, then run the project against a simulated brokerage account before considering any further development.

More than 250 participants from over a dozen countries gather in Hong Kong to build and present projects during a 24-hour hackathon. I introduce teams working on language learning, lending, customer relationship management, and other practical applications, then follow the event through judging and awards.

■ Projects and prototypes
- Cantonese pronunciation practice, personalized toy recommendations, loan matching, and volunteer coordination
- Local-AI CRM, invoice processing, and AI-assisted loan workflows
■ Hackathon process
- Team demos, submission challenges, judging criteria, finalist pitches, and awards
- Organizer and founder perspectives on Hong Kong’s technology community

For aspiring builders, startup teams, and anyone curious about hackathons, this offers examples of how teams scope and present prototypes under tight deadlines. Use the project ideas and judging criteria as prompts for choosing a problem and planning a small prototype of your own; detailed technical instructions or complete implementation guides are not covered.