AI & Machine Learning
Practical guides on AI tools, LLMs, and agent workflows.
Tutorials
LangGraph Module 9: Local Server, Studio, and Deployment
Run your graph with the LangGraph dev server, debug visually in Studio, call it over an API, and plan for production.
AI Agent Guardrails, Evaluation, and Production Readiness
Add limits, approvals, logging, and evaluation to make an agent safe, observable, and reliable enough to ship.
LangGraph Module 8: Parallel Branches and Subgraphs
Run steps in parallel, merge their results with reducers, and compose larger systems from smaller graphs.
LangChain Module 9: Observability, Testing, and Going to Production
Trace agent runs with LangSmith, test with a golden set, handle failures, and prepare a LangChain app for production.
Model Context Protocol (MCP) Basics: Connecting Agents to Tools
Understand what MCP is, build a tiny MCP server in Python, and learn how agents connect to MCP servers safely.
LangGraph Module 7: Streaming Output and Debugging
Stream state updates, tokens, and custom progress events from a graph, and learn to trace and debug runs.
LangChain Module 8: Middleware, Limits, and Human Approval
Customize the agent loop with middleware: summarization, approval for risky tools, call limits, and your own hooks.
Agent Workflow Patterns: Chaining, Routing, and Evaluator Loops
Learn the building-block workflow patterns that often beat a fully autonomous agent, with code for each.
LangGraph Module 6: Human-in-the-Loop with Interrupts
Pause a graph to ask a person for approval or input, then resume exactly where it stopped.
LangChain Module 7: RAG Part 2, Retrieval Agents and Two-Step Chains
Answer questions from your index two ways: a simple two-step flow, and an agent that decides when to retrieve.
AI Agent Memory and Context Management
Keep long-running agents effective with conversation history, summarization, external memory, and context limits in mind.
LangGraph Module 5: Persistence, Checkpointers, and Threads
Save graph state between runs with checkpointers, resume conversations by thread ID, and inspect history.
Building an AI Agent Loop in Python
Write a complete, safe agent loop that calls tools until the task is done, with a turn limit and error handling.
LangChain Module 6: RAG Part 1, Loading, Splitting, and Embedding Documents
Build a searchable knowledge base: load documents, split them, embed them locally, and query a vector store.
LangGraph Module 4: Building an LLM Agent with Tools from Scratch
Build the classic tool-calling agent loop as a graph: an LLM node, a tool node, and a conditional edge.
AI Agent Tools: How Function Calling Works
Define tools with JSON schemas, see how the model requests them, and return results correctly.
LangChain Module 5: Memory, Threads, and Long Conversations
Give an agent short-term memory with a checkpointer, separate conversations by thread, and keep history under control.
LangGraph Module 3: Conditional Edges, Routing, and Loops
Branch and loop your graph with conditional edges and Command, so the path depends on the state.
What Are AI Agents? Workflows vs Agents and the Agent Loop
Understand what makes an AI agent different from a chatbot or a fixed workflow, and when you actually need one.
LangChain Module 4: Tools and Your First Agent with create_agent
Define tools with @tool, build an agent with create_agent, and inspect the messages it produces.
RAG Step 5: Evaluation and Production Best Practices
Measure retrieval and answer quality, improve with hybrid search and reranking, and prepare a RAG system for production.
LangGraph Module 2: State Schemas and Reducers
Control how node updates merge into state with reducers, use message state, and separate input and output schemas.
LangChain Module 3: Structured Output with Pydantic
Get validated Python objects back from a model using with_structured_output and Pydantic schemas.
RAG Step 4: Generating Grounded Answers with Citations
Build the prompt from retrieved chunks, instruct the model to stay grounded, and return answers with source citations.
LangGraph Module 1: Introduction and Your First Graph
Learn what LangGraph is, how state, nodes, and edges fit together, and build and run your first graph.
RAG Step 3: Building a Reusable Retrieval Pipeline
Wrap embeddings and search into a small vector store class with metadata, score thresholds, and saving to disk.
LangChain Module 2: Chat Models, Messages, and Streaming
Work with the standard chat model interface: message formats, reading responses, streaming, and batching.
AI-Assisted Coding: A Workflow and Best Practices
A practical loop for coding with AI tools: plan, generate, review, test, and keep quality and security high.
LangChain Module 1: Introduction, Setup, and Your First Model Call
Understand what LangChain v1 is, install it, set your API key, and make your first model call.
RAG Step 2: Embeddings and Vector Search
Turn chunks into embedding vectors and find the most relevant ones for a question using cosine similarity.
GitHub Copilot: Getting Started for Developers
Set up GitHub Copilot in your editor and learn to use inline suggestions, chat, and project instructions effectively.
RAG Step 1: Loading and Chunking Documents
Extract text from files, split it into overlapping chunks, and attach metadata so retrieval returns useful passages.
Using ChatGPT and AI Chat Assistants for Everyday Work
Practical ways to use AI chat assistants for writing, research, analysis, and learning, and how to stay accurate and safe.
Langflow Module 10: Deployment and Security Best Practices
Run Langflow safely beyond your laptop with Docker, authentication settings, secrets, and hardening options.
RAG Explained: What Retrieval-Augmented Generation Is and When to Use It
Learn how RAG lets an LLM answer from your own documents, the architecture behind it, and when to choose it.
Prompt Injection and Safe Prompting
Understand direct and indirect prompt injection and apply layered defenses when LLMs process untrusted content.
Langflow Module 9: Langflow and the Model Context Protocol (MCP)
Expose your flows as MCP tools for other apps, and connect Langflow agents to external MCP servers.
Langflow Module 8: Writing Custom Components in Python
Extend Langflow with your own component: define inputs and outputs, place the file, and load it.
Evaluating and Iterating on Prompts Like Code
Build a test set, measure prompt changes, and improve prompts systematically instead of by guesswork.
Langflow Module 7: Global Variables, Export, and Version History
Manage secrets with global variables, share flows safely by exporting JSON, and use version history.
Getting Structured JSON Output from an LLM
Extract reliable, validated data from text using JSON schemas and Pydantic instead of fragile string parsing.
Langflow Module 6: Calling Flows from Code with the REST API
Create a Langflow API key and run any flow from curl or Python, with sessions and tweaks.
Langflow Module 5: RAG with Your Own Documents
Load, split, embed, and store documents, then build a retrieval flow that answers questions from them.
Prompt Engineering: Few-Shot Examples and Reasoning
Teach the model your format with examples, and get better answers on hard problems by encouraging step-by-step reasoning.
Langflow Module 4: Building an Agent with Tools
Build a tool-using agent from the Simple Agent template, and learn how Tool Mode connects components to the Agent.
Prompt Engineering: Writing Structured Prompts with Roles and Context
Build clear prompts from a role, task, context, constraints, and output format, and separate instructions from data.
Langflow Module 3: Components, Ports, and Connections
Learn how components connect, what the port colors mean, and how to build a flow from a blank canvas.
Choosing and Evaluating an LLM for Your Use Case
Pick a model by quality, speed, cost, and constraints, and compare candidates with a small test set of your own.
Langflow Module 2: Your First Flow with Basic Prompting
Create a flow from the Basic Prompting template, add your model provider key, and chat with it in the Playground.
Langflow Module 1: Introduction and Installation
Learn what Langflow is, choose how to run it, install it, and take a tour of the interface.
Calling an LLM API with Python: Your First Request
Make your first LLM API call with the Anthropic Python SDK, handle conversations, read usage, and handle errors.
LLM Hallucinations, Limitations, and Responsible Use
Learn why LLMs make things up, how to reduce errors, and the privacy, bias, and oversight issues to plan for.
LLM Tokens, Context Windows, and Sampling Explained
Count tokens, understand context limits and cost, and learn what temperature and top-p control.
How Large Language Models Work: A Practical Introduction
Understand tokens, next-token prediction, transformers, and the training stages behind modern LLMs, without the heavy math.
Saving and Deploying a Machine Learning Model as an API
Save a trained scikit-learn Pipeline with joblib, serve predictions with FastAPI, and plan for monitoring in production.
scikit-learn Pipelines and Feature Engineering
Combine preprocessing and modeling into one Pipeline so training and prediction stay consistent and leakage-free.
Overfitting, Cross-Validation, and Hyperparameter Tuning
Detect overfitting, get reliable estimates with cross-validation, and tune hyperparameters with GridSearchCV.
Evaluating Machine Learning Models: Accuracy, Precision, Recall, and More
Choose the right metric for classification and regression, and read a confusion matrix correctly.
Train/Test Split and Your First Model with scikit-learn
Split your data, train a classifier with scikit-learn, and measure how well it generalizes to unseen examples.
Data Preparation for Machine Learning with pandas
Load, inspect, and clean data with pandas, handling missing values and categorical columns before training.
Machine Learning Fundamentals: What It Is and How It Works
Understand what machine learning is, the main types, the key vocabulary, and the end-to-end workflow before writing any code.
Prompt Engineering 101: Getting Better Results from LLMs
Core techniques for writing prompts that produce more reliable AI output.