Langchain Fundamentals

LangChainOfficialPublished by LangChain

Skill
Tool integration
Data and AI
MIT
No issues found

Download ZIP

From the author

Create LangChain agents with create_agent, define tools, and use middleware for human-in-the-loop and error handling.

— the description by LangChain

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides the foundational patterns for building agents with LangChain. It focuses on the use of create_agent for orchestrating agent loops, defining tools with decorators, and implementing middleware for features like human-in-the-loop approval and state persistence. It also covers structured output generation and common debugging patterns for agent execution.

What it does

Initializes agents using the create_agent function.
Defines custom tools using the @tool decorator or tool function.
Configures state persistence using MemorySaver checkpointers.
Implements middleware for human-in-the-loop approval and custom hooks.
Enforces structured output using response_format or with_structured_output.
Provides patterns for fixing common issues like missing tool descriptions or infinite loops.

When to use it

When you need to build agents that require tool execution and state management.
When implementing human-in-the-loop approval workflows for agent actions.
When you need to ensure agents return data in a specific, validated format.
When debugging agent behavior related to memory, tool selection, or execution limits.

Advantages

Standardizes agent creation using the recommended create_agent approach.
Simplifies tool definition with clear decorator patterns.
Provides built-in support for conversation memory and state persistence.
Enables granular control over agent execution via middleware.

Usage examples

“How do I create a basic agent with a weather tool?”: The agent is initialized using create_agent with a model, a list of tools defined by the @tool decorator, and a system prompt.
“How can I make my agent remember previous messages?”: You must pass a MemorySaver checkpointer to the create_agent configuration and provide a thread_id in the invocation config.
“How do I add human approval before an agent executes a tool?”: Use the HumanInTheLoopMiddleware in the agent configuration and handle the interruption using the checkpointer.
“How do I prevent my agent from looping indefinitely?”: Set a recursion_limit within the invocation configuration to cap the number of steps the agent can take.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/langchain-ai/langchain-fundamentals/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip langchain-fundamentals.zip -d .agents/skills

Documentation by LangChain

<oneliner> Build production agents using `create_agent()`, middleware patterns, and the `@tool` decorator / `tool()` function. When creating LangChain agents, you MUST use create_agent(), with middleware for custom flows. All other alternatives are outdated. </oneliner>

<create_agent>

Creating Agents with create_agent

create_agent() is the recommended way to build agents. It handles the agent loop, tool execution, and state management.

Agent Configuration Options

Parameter	Purpose	Example
`model`	LLM to use	`"anthropic:claude-sonnet-4-5"` or model instance
`tools`	List of tools	`[search, calculator]`
`system_prompt` / `systemPrompt`	Agent instructions	`"You are a helpful assistant"`
`checkpointer`	State persistence	`MemorySaver()`
`middleware`	Processing hooks	`[HumanInTheLoopMiddleware]` (Python) / `[humanInTheLoopMiddleware({...})]` (TypeScript)
</create_agent>

<ex-basic-agent> <python>

from langchain.agents import create_agent
from langchain_core.tools import tool

@tool
def get_weather(location: str) -> str:
    """Get current weather for a location.

    Args:
        location: City name
    """
    return f"Weather in {location}: Sunny, 72F"

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",
    tools=[get_weather],
    system_prompt="You are a helpful assistant."
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "What's the weather in Paris?"}]
})
print(result["messages"][-1].content)

</python> <typescript>

import { createAgent } from "langchain";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const getWeather = tool(
  async ({ location }) => `Weather in ${location}: Sunny, 72F`,
  {
    name: "get_weather",
    description: "Get current weather for a location.",
    schema: z.object({ location: z.string().describe("City name") }),
  }
);

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5",
  tools: [getWeather],
  systemPrompt: "You are a helpful assistant.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "What's the weather in Paris?" }],
});
console.log(result.messages[result.messages.length - 1].content);

</typescript> </ex-basic-agent>

<ex-agent-with-persistence> <python> Add MemorySaver checkpointer to maintain conversation state across invocations.

from langchain.agents import create_agent
from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",
    tools=[search],
    checkpointer=checkpointer,
)

config = {"configurable": {"thread_id": "user-123"}}
agent.invoke({"messages": [{"role": "user", "content": "My name is Alice"}]}, config=config)
result = agent.invoke({"messages": [{"role": "user", "content": "What's my name?"}]}, config=config)
# Agent remembers: "Your name is Alice"

</python> <typescript> Add MemorySaver checkpointer to maintain conversation state across invocations.

import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

const checkpointer = new MemorySaver();

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5",
  tools: [search],
  checkpointer,
});

const config = { configurable: { thread_id: "user-123" } };
await agent.invoke({ messages: [{ role: "user", content: "My name is Alice" }] }, config);
const result = await agent.invoke({ messages: [{ role: "user", content: "What's my name?" }] }, config);
// Agent remembers: "Your name is Alice"

</typescript> </ex-agent-with-persistence>

<tools> ## Defining Tools

Tools are functions that agents can call. Use the @tool decorator (Python) or tool() function (TypeScript). </tools>

<ex-basic-tool> <python>

from langchain_core.tools import tool

@tool
def add(a: float, b: float) -> float:
    """Add two numbers.

    Args:
        a: First number
        b: Second number
    """
    return a + b

</python> <typescript>

import { tool } from "@langchain/core/tools";
import { z } from "zod";

const add = tool(
  async ({ a, b }) => a + b,
  {
    name: "add",
    description: "Add two numbers.",
    schema: z.object({
      a: z.number().describe("First number"),
      b: z.number().describe("Second number"),
    }),
  }
);

</typescript> </ex-basic-tool>

<middleware> ## Middleware for Agent Control

Middleware intercepts the agent loop to add human approval, error handling, logging, and more. A deep understanding of middleware is essential for production agents — use HumanInTheLoopMiddleware (Python) / humanInTheLoopMiddleware (TypeScript) for approval workflows, and @wrap_tool_call (Python) / createMiddleware (TypeScript) for custom hooks.

Key imports:

from langchain.agents.middleware import HumanInTheLoopMiddleware, wrap_tool_call

import { humanInTheLoopMiddleware, createMiddleware } from "langchain";

Key patterns:

HITL: middleware=[HumanInTheLoopMiddleware(interrupt_on={"dangerous_tool": True})] — requires checkpointer + thread_id
Resume after interrupt: agent.invoke(Command(resume={"decisions": [{"type": "approve"}]}), config=config)
Custom middleware: @wrap_tool_call decorator (Python) or createMiddleware({ wrapToolCall: ... }) (TypeScript)
</middleware>

<structured_output>

Structured Output

Get typed, validated responses from agents using response_format or with_structured_output().

from langchain.agents import create_agent
from pydantic import BaseModel, Field

class ContactInfo(BaseModel):
    name: str
    email: str
    phone: str = Field(description="Phone number with area code")

# Option 1: Agent with structured output
agent = create_agent(model="gpt-4.1", tools=[search], response_format=ContactInfo)
result = agent.invoke({"messages": [{"role": "user", "content": "Find contact for John"}]})
print(result["structured_response"])  # ContactInfo(name='John', ...)

# Option 2: Model-level structured output (no agent needed)
from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-4.1")
structured_model = model.with_structured_output(ContactInfo)
response = structured_model.invoke("Extract: John, [email protected], 555-1234")
# ContactInfo(name='John', email='[email protected]', phone='555-1234')

</python> <typescript>

import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";

const ContactInfo = z.object({
  name: z.string(),
  email: z.string().email(),
  phone: z.string().describe("Phone number with area code"),
});

// Model-level structured output
const model = new ChatOpenAI({ model: "gpt-4.1" });
const structuredModel = model.withStructuredOutput(ContactInfo);
const response = await structuredModel.invoke("Extract: John, [email protected], 555-1234");
// { name: 'John', email: '[email protected]', phone: '555-1234' }

</typescript> </structured_output>

<model_config>

Model Configuration

create_agent accepts model strings ("anthropic:claude-sonnet-4-5", "openai:gpt-4.1") or model instances for custom settings:

from langchain_anthropic import ChatAnthropic
agent = create_agent(model=ChatAnthropic(model="claude-sonnet-4-5", temperature=0), tools=[...])

</model_config>

<fix-missing-tool-description> <python> Clear descriptions help the agent know when to use each tool.

# WRONG: Vague or missing description
@tool
def bad_tool(input: str) -> str:
    """Does stuff."""
    return "result"

# CORRECT: Clear, specific description with Args
@tool
def search(query: str) -> str:
    """Search the web for current information about a topic.

    Use this when you need recent data or facts.

    Args:
        query: The search query (2-10 words recommended)
    """
    return web_search(query)

</python> <typescript> Clear descriptions help the agent know when to use each tool.

// WRONG: Vague description
const badTool = tool(async ({ input }) => "result", {
  name: "bad_tool",
  description: "Does stuff.", // Too vague!
  schema: z.object({ input: z.string() }),
});

// CORRECT: Clear, specific description
const search = tool(async ({ query }) => webSearch(query), {
  name: "search",
  description: "Search the web for current information about a topic. Use this when you need recent data or facts.",
  schema: z.object({
    query: z.string().describe("The search query (2-10 words recommended)"),
  }),
});

</typescript> </fix-missing-tool-description>

<fix-no-checkpointer> <python> Add checkpointer and thread_id for conversation memory across invocations.

# WRONG: No persistence - agent forgets between calls
agent = create_agent(model="anthropic:claude-sonnet-4-5", tools=[search])
agent.invoke({"messages": [{"role": "user", "content": "I'm Bob"}]})
agent.invoke({"messages": [{"role": "user", "content": "What's my name?"}]})
# Agent doesn't remember!

# CORRECT: Add checkpointer and thread_id
from langgraph.checkpoint.memory import MemorySaver

agent = create_agent(
    model="anthropic:claude-sonnet-4-5",
    tools=[search],
    checkpointer=MemorySaver(),
)
config = {"configurable": {"thread_id": "session-1"}}
agent.invoke({"messages": [{"role": "user", "content": "I'm Bob"}]}, config=config)
agent.invoke({"messages": [{"role": "user", "content": "What's my name?"}]}, config=config)
# Agent remembers: "Your name is Bob"

</python> <typescript> Add checkpointer and thread_id for conversation memory across invocations.

// WRONG: No persistence
const agent = createAgent({ model: "anthropic:claude-sonnet-4-5", tools: [search] });
await agent.invoke({ messages: [{ role: "user", content: "I'm Bob" }] });
await agent.invoke({ messages: [{ role: "user", content: "What's my name?" }] });
// Agent doesn't remember!

// CORRECT: Add checkpointer and thread_id
import { MemorySaver } from "@langchain/langgraph";

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-5",
  tools: [search],
  checkpointer: new MemorySaver(),
});
const config = { configurable: { thread_id: "session-1" } };
await agent.invoke({ messages: [{ role: "user", content: "I'm Bob" }] }, config);
await agent.invoke({ messages: [{ role: "user", content: "What's my name?" }] }, config);
// Agent remembers: "Your name is Bob"

</typescript> </fix-no-checkpointer>

<fix-infinite-loop> <python> Set recursion_limit in the invoke config to prevent runaway agent loops.

# WRONG: No iteration limit - could loop forever
result = agent.invoke({"messages": [("user", "Do research")]})

# CORRECT: Set recursion_limit in config
result = agent.invoke(
    {"messages": [("user", "Do research")]},
    config={"recursion_limit": 10},  # Stop after 10 steps
)

</python> <typescript> Set recursionLimit in the invoke config to prevent runaway agent loops.

// WRONG: No iteration limit
const result = await agent.invoke({ messages: [["user", "Do research"]] });

// CORRECT: Set recursionLimit in config
const result = await agent.invoke(
  { messages: [["user", "Do research"]] },
  { recursionLimit: 10 }, // Stop after 10 steps
);

</typescript> </fix-infinite-loop>

<fix-accessing-result-wrong> <python> Access the messages array from the result, not result.content directly.

# WRONG: Trying to access result.content directly
result = agent.invoke({"messages": [{"role": "user", "content": "Hello"}]})
print(result.content)  # AttributeError!

# CORRECT: Access messages from result dict
result = agent.invoke({"messages": [{"role": "user", "content": "Hello"}]})
print(result["messages"][-1].content)  # Last message content

</python> <typescript> Access the messages array from the result, not result.content directly.

// WRONG: Trying to access result.content directly
const result = await agent.invoke({ messages: [{ role: "user", content: "Hello" }] });
console.log(result.content); // undefined!

// CORRECT: Access messages from result object
const result = await agent.invoke({ messages: [{ role: "user", content: "Hello" }] });
console.log(result.messages[result.messages.length - 1].content); // Last message content

</typescript> </fix-accessing-result-wrong>

Files

ATTRIBUTION.mdAdded by AutoGineer906 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md12.2 KiB

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by

LangChain

Publisher

LangChain (Official)

Source

langchain-ai/langchain-skills · config/skills/langchain-fundamentals · commit 126c384

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by LangChain or LangChain.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download langchain-fundamentals.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by LangChain

Creating Agents with create_agent

Agent Configuration Options

Structured Output

Model Configuration

Files

Requirements and compatibility

Security

Attribution and licence

Related skills

Claude API

Transformers

Open Notebook

Vision Sft

LLM Evaluation

Lora Qlora Recipes

Download ZIP