AI Engineering with LangChain for JavaScript Developers

Learn to build your first LangChain agent in JavaScript using a unified tool-driven workflow that abstracts provider differences and enables easy switching between OpenAI and Anthropic.

Set up a test Next.js project to power an agent, using the Sass starter, Neon Postgres, Stripe, and Drizzle ORM, then initialize the environment file, migrate, seed, and run locally.

Compare short-term memory, per-thread state with checkpoints, to long-term memory, a cross-thread store. Use store.put with namespaces and runtime context for cross-run access.

Customize the agent's short-term memory by extending the state with a custom schema and middleware, recording findings in memory and retrieving them with a get findings tool.

Define a schema for structured output in LangChain, then generate and validate outputs against it using provider strategy or tool strategy, ensuring consistent shapes across agents.

Explore LangChain middleware, using node-style and wrap-style hooks to control the agent loop, including before/after model and before/after agent, and dynamically manage tools, logging, and PII masking.

Explore creating custom middleware in LangChain for JavaScript developers, using before/after, guardrails, and wrap model calls to tailor tools by user role, with robust error handling.

Examine how to log middleware actions, test PII masking, and verify dynamic system prompts and tool selections using the demos.

Discover how LangChain uses LangGraph interrupts to pause and resume graph execution with a human-in-the-loop middleware, enabling approve, edit, or reject for tool calls.

Explore how AI Copilot agents populate the graph with researchers, planners, and coders who use tools to research, plan, code, and seek human approval for GitHub pull requests.

Define and implement file tools to let agents explore a code base by listing directories, reading text files, and searching within files, using LangChain tools and runtime context.

Test file tools with a repo reader agent in Langsmith Studio, hard code repo path, and use list directory, search in files, and read file tools.

Create a researcher agent that searches the web and documentation with Tavli in LangChain for JavaScript, using web and documentation search tools.

Implement and test a researcher agent that outputs a structured research summary, list of libraries, suggested approach, risks, and sources, using web search, docs, and read file tools.

Master retrieval augmented generation (RAG) with embeddings and vector stores to answer questions from your data. Chunk documents, encode into vectors, and use a Chroma vector database for semantic search.

Explains embedding vectors with a text embeddings model, compares similarities using cosine similarity, and sets up a local chroma database with docker for development, including an embeddings.ts example.

Vectorize the codebase, split into chunks, and embed them before storing in a ChromaDB vector store. This one-time indexing prepares semantic search with LangChain, TypeScript, Markdown, and code-aware splitters.

Discover how the planner agent uses file tools, semantic search, and optional web search to craft an engineering plan from a feature request, guided by a system prompt.

Test the planner agent by registering it in Langraff.json, connecting a demo planner.ts to the agent studio, and passing a generated research summary to produce a task-driven plan.

Explore creating the clarify function in a LangChain for JavaScript workflow, using a direct LLM call, project context, and structured outputs to decide if more information is needed.

Develop and test a coder agent that turns a plan into code changes using a change set schema, editing and creating files, and running commands within a land graph.

Test the coder agent with the planner’s engineering plan and feature request, then verify the change set schema and resulting file edits from the plan.

Learn to build a Langraph graph for a LangChain agent with nodes and edges, define per-thread state and reducer values, and output a polished report from start to end.

Explore persistence and check pointers in LangGraph and LangChain to snapshot graph state after each super step, enabling human-in-the-loop workflows, conversational memory, fault tolerance, and time traveling.

Explore a practical demo of persistence in LangChain graphs, creating runs and checkpoints, updating state, and time traveling through history, branching, and forking.

Explore how interrupt() pauses a Lang graph to gather user input, resume with a decision, and manage checkpoints, payloads, and idempotent safeguards.

Implement a simplified React agent from scratch with LangGraph, mirroring LangChain's approach by wiring an LLM to call tools like getWeather and getPopulation and feeding results back to the LLM.

Define and manage the graph state for an AI copilot, including repository cloning, runtime paths, clarify flows, and plan execution from researcher to coder.

implement the clarify node in a LangChain graph, using an llm to decide feature request clarity, interrupt for human input, and refine the request for the researcher node.

Set up and connect researcher and planner nodes in a lang graph, invoke agents, pass clarified feature requests and research summaries, and prepare planner outputs for human review.

Learn how to run multiple coder nodes in parallel by grouping tasks with dependencies, spawning coder agents for independent tasks, and aggregating changeset schemas into a unified plan.

Create and connect a state graph by wiring setup, clarify, researcher, planner, coder, and clean up nodes with defined edges, then test with feature requests and parallel execution.

implement the executor node to merge change sets, apply edits and create new files, run trusted commands, install new dependencies, and perform targeted TypeScript checks on changed files.

Create a new branch, commit and push changes, then open a pull request with a generated description, using a token from environment variables and resilient handling for resumed runs.

Learn to store a feature plan summary in long-term memory using an LLM, extract files changed, key decisions, and patterns, then enable semantic search for past features.

Assemble and connect the completed nodes into a final graph, wire edges across setup, clarify, researcher, planner, coders, executor, and retry coder that clears the chain sets, then test visualization.

Implement per-node retry policies in the copilot file to handle network and llm errors, retrying rate limit errors (codes 503, 529) while avoiding retries for input or schema issues.