LangGraph Mastery: Develop LLM Agents with LangGraph

Develop a basic agent from scratch using the react pattern, where the LLM reasons, acts in an environment, and iterates with observations until it completes.

Create an agent class that initializes system and messages list, handles user prompts via __call__, then uses a chat completions API with GPT four mini to return the assistant's response.

Explore the react prompt framework guiding a language model through a loop of thought, action, pause, and observation, with actions like calculate, get, cost, and Wikipedia.

Create and test Python tools for calculations, cost lookups, and a Wikipedia search using the Wikipedia API; build the known actions map and prepare the agent with tools.

Initialize an llm agent with a system prompt, using prompts and tools to perform actions, observe results, and produce final answers, including pen and book cost calculations.

Automate the agent by looping prompts, parsing actions with a regex from the LLM response, and executing tool functions until a final answer.

Explore Landgraf concepts and core components, including graph structures of nodes and edges, agent state, and conditional flows, plus flow engineering to build controlled, interactive LLM-powered workflows.

Build a simple chatbot in LangGraph using line graph by defining a state graph with messages and an annotated node that appends responses, then compile and run the graph.

Visualize the graph to reveal how nodes connect, using IPython dot display to render as PNG or ASCII, and install Gandalf for ASCII output.

Build and run a chatbot app that interacts with an LLM in a loop, prompting input, exiting on quit, syncing input to Landgraaf, and printing the last message.

Explore Tavili AI, a large language model–optimized search engine for agentic search. Install the Python library, set API keys with dotenv, and run basic, advanced, and QnA searches.

Enhance the chatbot by integrating a Tivoli search tool, wiring it through a tool node and conditional edges so it retrieves updated information beyond training data.

Develop memory for the chatbot by implementing persistent checkpointing with a graph, saving state after each step using a thread id to enable seamless multi-turn conversations.

Explore reflection as metacognition for language models: monitor, evaluate, and adapt based on prior actions and tool feedback to improve future decisions, especially in knowledge-intensive tasks.

Develop an lm agentic app with a line graph to generate and refine a tweet on a subject through generate, reflect, give feedback, and refine, then post on X.

Apply the reflection technique to generate, critique, and improve a tweet via a reflect chain that acts as a critic, repeating steps to refine the final output.

Connect the graph by defining nodes, edges, and an end node, build a message graph with generate and reflect nodes, and iteratively refine tweets from a stateful message history.

Define the conditional edge in the graph to route control flow between generate and reflect, enabling six iterations before finishing, with a loop back to generate.

Demonstrates building an app workflow with a generation and reflection chain, using a line graph to iterate revisions and finalize a tweet about FIFA World Cup 26.

Locksmith provides a production-grade LMDh platform, integrates with lane chain and lane graph, and supports tracing, evaluation, testing, real-time monitoring, and collaborative feedback to ship reliable llm applications.

Set up LangSmith to capture traces of user interactions, detailing inputs and outputs across multiple steps, and create an API key for authentication.

Configure environment variables and use locksmith to log traces of LLM interactions with LangSmith, using the traceable decorator to capture inputs, outputs, and run pipelines for debugging.

Explore tracing a reflective agentic app in LangGraph Mastery, using LangSmith for long-chain tracing, reflect chains, and iterative prompts to improve a generated tweet while logging interactions.

Develop an advanced LangGraph project by using reflection and tool observation to plan, research with AI, generate an essay, critique, and iteratively refine until criteria are met.

Load API keys from Dotenv, define the agent state with a typed dict, set up planning, researching, writing, critique prompts, and queries, and instantiate a LangGraph LLM client.

Develop the agents and nodes for an llm app by building a planning node, research plan node, draft generation, and reflection, then refine with critique and further research.

Define the should continue conditional edge in the state graph to govern essay revisions; the function compares the revision number to the maximum, signaling reflection or end after generation.

Define a state graph with agent state, add planning, generating drafts, reflecting, and researching nodes, set the plan node as entry, and implement a checkpointing mechanism to save progress.

Trace and debug a LangGraph LM app with LangSmith. Load dotenv variables, enable long chain tracing v2, create a project, and view prompts, inputs, outputs, and execution time.

Create a research agent using link graph by integrating Python basics, external libraries, JSON, web scraping, and embeddings with OpenAI API, and pinecone vector stores.

Introduce an advanced ai research agent built with Linkchain and Landgraaf, using retrieval augmented generation, a private knowledge base with Pinecone, Serp API searches, arXiv sources, and an Oracle LM.

Extract arXiv data into a pandas dataframe and save as json, demonstrating xml parsing, http requests to the arXiv api, and json conversion for AI research pipelines.

Download pdf files from the data frame's urls, save them locally, and record their names; then split, embed, and upload the chunks to pinecone for retrieval augmented generation.

Load PDFs, split into 512-character chunks with a 64-character overlap, embed the chunks, and expand the data frame with chunk metadata for efficient retrieval and generation in a vector store.

Set up Pinecone, a managed vector database, to store and query embeddings with cosine similarity for semantic search and recommendations, using an index on AWS US East 1.

Populate the knowledge base by processing data in batches, extracting metadata, and converting chunks into embeddings, then upload them to pinecone for a searchable vector store.

Develop custom tools within a LangGraph graph to fetch abstracts, perform searches, and format final research reports using a pinecone-backed knowledge base and embeddings for the rec system.

Implement the arXiv fetch tool to retrieve a paper abstract via an HTTP GET request and extract it with a regex, using Python requests and a LangChain tool decorator.

Integrate the Google Serp API to power web search within LangGraph Mastery, access structured results, and enable SEO analysis and data mining with a Serp API key loaded from dotenv.

Implement a web search tool with Google Serp API, securely handling the API key from environment variables and returning up to five organic results.

Develop and implement retrieval augmented generation tools using pinecone embeddings to perform targeted and broad searches, format results for display, and build RAG workflows for language model agents.

Design the answer generation tool that gathers information from FAQs, archive, and web search. Format research steps as bullets and assemble a report with introduction, main body, conclusion, and sources.

Explore how the oracle LLM acts as a graph decision maker, selecting tools such as archives or web search, using a scratchpad to guide final answers.

Test the oracle-driven LangGraph workflow by passing inputs, embedding arXiv queries, indexing with pinecone, and validating tool choices (web search, fetch archive) via scratchpad and system rules.

Build a decision-making pipeline that coordinates oracle routing and tool execution. Track intermediate steps, tool calls, and agent actions to generate and log structured outputs toward the final answer.

Define a custom graph state to support agentic decision making by importing components, using typed dicts and annotated types, and tracking input, chart history, and intermediate steps with agent actions.

Define the decision-making graph by adding nodes for oracle and tools, connect them with conditional edges via the router, set oracle as the entry point, then compile and run.

Develop and execute an agent-driven workflow using a state graph to select tools, collect outputs, and generate a formatted final report for a research topic.

Build a report function formats graph data into a research report, converting steps and sources into bullet lists and organizing sections such as introduction, research steps, report, conclusion, and sources.

Explore how object oriented programming models real world objects using classes, objects, attributes, and methods. Learn how Python supports OOP as a multi-paradigm approach that complements procedural programming.

Explore object-oriented programming with the turtle library in Python, creating and using objects, classes, and methods to draw, and study abstraction and encapsulation.

Define a class with the class keyword and a Pascal-case name, using indentation and a pass statement. Create an instance and access its docstring via dot notation and __doc__.

Learn how the __init__ method serves as the class constructor, automatically invoked when creating a new instance, and how to use self to assign attributes like name and year.

Explore the Python class destructor, the __del__ method, which frees resources when an object's lifetime ends, and its relation to Python's garbage collector and C plus plus destructors.

Explore the difference between instance and class attributes in Python, learn to create and access them with methods like set_energy and getattr, and track a class-wide population counter.

Learn how Python magic methods (dunder methods) enable operator overloading and custom object behavior, with examples of custom string representations and adding their prices.

Typed dicts in Python 3.8 enable static type checking for dictionaries with fixed keys, improving readability, maintainability, and reliability through defined key types and type hints.

Explore how typed dicts support optional keys with total=False, access keys safely with get, and nest typed dicts to model complex data like a user with an address.