Master LangGraph v1 and Ollama - Build Gen AI Agents

Test benchmark questions locally with Qwen3 to compare its reasoning on physics and algebra problems against GPT-5, using live coding and a ChatGPT evaluator.

Start ollama serve, explore models via the UI and terminal, and manage models with pull, show, and rm commands.

Learn to copy models using the Ollama cp command and track them with the Ollama ps. Name copies, adjust parameters, and monitor CPU, GPU usage and context windows across runs.

Explore Ollama message commands and the message mode to view model details, parameters, and licenses. Learn to manage llama 3.2 models and Seldon models.

Learn to use Ollama raw API requests for generating completions and chat completions, including streaming options, model creation, and JSON output.

Learn to download a GGUF model from Hugging Face and load an uncensored wizard LM model into Ullama for local LLM experimentation, including file paths, system prompts, and UI checks.

Calculate VRAM requirements for Qwen3.5, Nemotron, and Mixtrel on Ollama (2026), including 4-bit quantization, tokenizer and metadata overhead, vision memory, and dense versus mixture-of-experts architectures.

Explore dense transformers, sparse mixture of experts, and mamba architectures, focusing on routers, selective activation, and kvcache versus ssm state compression.

Evaluate dense, sparse, and hybrid transformer models for LeetCode hard problems locally with Ullama, focusing on Nemotron 3 nano 4B and QIN 3.59B/3.535B models.

Benchmark the Nemotron 3 nano 30B on LeetCode hard problems using the Ulama desktop workflow, showcasing problem ingestion, solution generation, and test-case validation at high speed.

Explore loop engineering with the react agent, detailing how input prompts trigger action, observation, and tool use, plus a two-model, memory-sharing loop for self-prompting improvement.

Set up and configure a local llama-based model with Gemma3, including environment variables, base URL, and stable Python version considerations to control temperature and token limits.

Master generating responses with Gemma3, tracing in Langsmith, and coordinating system, human, and AI messages to support LangGraph and LangChain workflows.

Reuse prompts efficiently by using the chat prompt template to set system and human message placeholders and replace them at runtime with audience, subject, and topic parameters.

Create a single-line LangChain chain by binding a prompt to an LM, invoke with inputs like subject, audience, and topic, and observe the populated prompt and final output.

Stream real time output from the LLM using a structured Pydantic model and an output parser to reveal sentiment and reasoning.

Explore flow engineering and finite state machines to build LangGraph with state, node, and edge. Design start and end nodes, custom and pre-built nodes, and maintain message history within LangGraph.

Define a custom state in LangGraph by extending type dict, using a state graph canvas to hold nodes and edges, and modeling input and output text with typed fields.

Build your first LangGraph by creating a state graph canvas, adding a simple state with input and output text, connecting nodes, and compiling the graph for visualization.

Define a custom state for a tweet and perform sentiment analysis in a LangGraph node. Generate a warm positive response using a system and human message flow.

Develop a negative sentiment node and a sentiment router to direct to positive or negative responses based on sentiment state and confidence, using system messages.

Design and implement a LangGraph for sentiment analysis and tweet replies, including router logic, analyze node, positive and negative response nodes, edge wiring, and compile.

Manage state in agents by modeling a messages history—human, system, AI, and tool messages in LangGraph—and append outputs without overwriting using annotated typing.

Learn to implement an agent state with an annotated reducer to maintain message history, attach a tool node, and configure a practical Python workflow for state updates.

Import and invoke weather and calculate tools, pass inputs like Mumbai, and verify outputs; then design a line-graph workflow with an agent, tool nodes, and a start-to-end flow.

Debug the agent node to test tool calls, verify the calculate tool invocation via proper docstrings, and observe how responses are returned as message lists within a LangGraph line graph.

Implement a router named should continue that inspects the latest agent state message, routes tool calls through the tool node, and ends the process to produce the final answer.

Define the create agent method to build a LangGraph agent with an agent node and a tool node, connected by conditional edges.

See how an agent manages states and executes multiple tool calls in parallel, generating a final answer. Leverage line chain and line graph concepts to produce structured output.

Import the tools by modifying the system path, create the agent state and agent node, and configure a memory enabled friendly assistant that uses weather and calculator tools.

Learn to stream agent output with LangChain, maintain memory across chats, and debug streaming chunks from agent and tools using thread IDs and messages.

Learn to design production ready memory for LM apps, using short term memory for thread IDs and long term memory for user IDs, with episodic, semantic, and procedural memories.

Manage short term memory through the agent state and thread id, while long term memory stores episodic, semantic, and procedural memories with databases like SQLite and PostgreSQL.

Explore managing short-term working memory and chat history for agentic RAG, capturing user queries and model outputs, and storing memory in SQLite or PostgreSQL.

Leverage a persistence memory notebook to build a LangGraph and LangChain agent, importing tooling, managing agent state and messages, and adding SQLite or Postgres memory persistence for persistent chats.

Persist short term memory in PostgreSQL by setting up a free Neon database, connecting via a URL loaded from .env, and restarting to load the environment variable for LangChain.

Persist the agent's memory to a remote PostgreSQL database using LangChain, by configuring the memory store, automatically creating tables, and storing chat histories as encoded blobs.

Explore connecting to PostgreSQL using from connection string in Lightchain, with a memory-backed checkpoint, and an agent that stores and recalls questions across sessions.

Store, retrieve, and delete long-term memory in PostgreSQL using a memory namespace, with put, get, and delete operations to manage keys like color, work, and role for a user.

Learn to build an agent node by attaching tools, integrating memory with semantic search, and enabling save and retrieval of user memory using a defined namespace and user id.

Explore how an agent uses long-term and short-term memory, plus memory tools, to retrieve user context and preserve memory across thread IDs for personalized outputs.