Skip to content

Commit 456f57c

Browse files
lnhsinghlnhsingh
authored
add custom SKILL.md (langchain-ai#3757)
Fixes DOC-641 Add custom skill.md files for AI agent discovery across all four products (LangSmith, LangChain, LangGraph, Deep Agents) using Mintlify's .mintlify/skills/ multi-skill directory, so AI agents can discover and selectively load product-specific capabilities via /.well-known/agent-skills/index.json.
1 parent db8ce3d commit 456f57c

4 files changed

Lines changed: 432 additions & 0 deletions

File tree

‎src/.mintlify/skills/deep-agents/SKILL.md‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
1+
---
2+
name: deep-agents
3+
description: Build batteries-included agents with planning, context management, subagent delegation, and sandboxed execution. Use for complex, multi-step tasks that need built-in capabilities.
4+
license: MIT
5+
compatibility: Python 3.10+, Node.js 20+. Requires a model that supports tool calling.
6+
metadata:
7+
author: langchain-ai
8+
version: "1.0"
9+
---
10+
11+
# Deep Agents
12+
13+
Deep Agents is the easiest way to start building agents powered by LLMs—with built-in capabilities for task planning, file systems for context management, subagent delegation, and long-term memory. It is an "agent harness" built on [LangChain](https://docs.langchain.com/oss/langchain/overview) core building blocks and the [LangGraph](https://docs.langchain.com/oss/langgraph/overview) runtime.
14+
15+
## When to use
16+
17+
Use Deep Agents when you need to:
18+
- **Build agents fast** with sensible defaults and minimal configuration
19+
- **Handle complex, multi-step tasks** that benefit from automatic planning
20+
- **Manage context** with a built-in virtual filesystem for large inputs
21+
- **Delegate subtasks** to specialized subagents
22+
- **Run code safely** in sandboxed execution environments
23+
- **Use a terminal agent** via the Deep Agents CLI
24+
25+
## When NOT to use
26+
27+
- For simple tool-calling agents without planning or subagents, use [LangChain](https://docs.langchain.com/oss/langchain/overview) agents instead—lighter weight
28+
- For custom graph-based orchestration with explicit control flow, use [LangGraph](https://docs.langchain.com/oss/langgraph/overview) directly
29+
- Deep Agents is the **highest-level abstraction**—it trades flexibility for convenience
30+
31+
## Install
32+
33+
```bash
34+
# Python
35+
pip install deepagents
36+
37+
# JavaScript/TypeScript
38+
npm install deepagents langchain @langchain/core
39+
```
40+
41+
## Quick reference
42+
43+
### Create a deep agent
44+
45+
```python
46+
# pip install deepagents langchain-anthropic
47+
from deepagents import create_deep_agent
48+
49+
def get_weather(city: str) -> str:
50+
"""Get weather for a given city."""
51+
return f"It's always sunny in {city}!"
52+
53+
agent = create_deep_agent(
54+
model="anthropic:claude-sonnet-4-6",
55+
tools=[get_weather],
56+
system_prompt="You are a helpful assistant",
57+
)
58+
59+
result = agent.invoke(
60+
{"messages": [{"role": "user", "content": "What is the weather in SF?"}]}
61+
)
62+
```
63+
64+
### Use the CLI
65+
66+
```bash
67+
# Install the CLI
68+
pip install deepagents-cli
69+
70+
# Run an interactive terminal agent
71+
deepagents
72+
```
73+
74+
### Built-in capabilities
75+
76+
| Capability | Description |
77+
|-----------|-------------|
78+
| Planning | Automatic task decomposition for complex requests |
79+
| File system | Virtual filesystem for reading, writing, and managing context |
80+
| Subagents | Spawn child agents for parallel subtask execution |
81+
| Context management | Automatic context compression for long conversations |
82+
| Sandboxed execution | Run code in isolated environments (Modal, Runloop, Daytona) |
83+
| Protocols | ACP, MCP, and A2A support for interoperability |
84+
85+
## Key documentation
86+
87+
- [Overview](https://docs.langchain.com/oss/deepagents/overview)—What Deep Agents is and how it compares to LangChain and LangGraph
88+
- [Quickstart](https://docs.langchain.com/oss/deepagents/quickstart)—Build your first deep agent
89+
- [Customization](https://docs.langchain.com/oss/deepagents/customization)—Configure models, tools, and behavior
90+
- [Context engineering](https://docs.langchain.com/oss/deepagents/context-engineering)—Manage context for complex tasks
91+
- [Subagents](https://docs.langchain.com/oss/deepagents/subagents)—Delegate work to child agents
92+
- [Sandboxes](https://docs.langchain.com/oss/deepagents/sandboxes)—Run code in isolated environments
93+
- [CLI](https://docs.langchain.com/oss/deepagents/cli/overview)—Terminal agent interface
94+
- [Deploy](https://docs.langchain.com/oss/deepagents/deploy)—Deploy to production
95+
96+
## API reference
97+
98+
For SDK class and method details, use the [LangChain API Reference](https://reference.langchain.com) site:
99+
- MCP server: `https://reference.langchain.com/mcp`
100+
101+
## Related skills
102+
103+
- **langchain**—Core building blocks that Deep Agents is built on
104+
- **langgraph**—Runtime that powers Deep Agents' durable execution
105+
- **langsmith**—Trace, evaluate, and deploy your deep agents

‎src/.mintlify/skills/langchain/SKILL.md‎

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
---
2+
name: langchain
3+
description: Build agents with a prebuilt architecture and integrations for any model or tool. Use when creating tool-calling agents, switching model providers, or adding structured output.
4+
license: MIT
5+
compatibility: Python 3.10+, Node.js 20+
6+
metadata:
7+
author: langchain-ai
8+
version: "1.0"
9+
---
10+
11+
# LangChain
12+
13+
LangChain is an open-source framework with a prebuilt agent architecture and integrations for any model or tool. Build agents and LLM-powered applications in under 10 lines of code, with integrations for OpenAI, Anthropic, Google, and hundreds more.
14+
15+
## When to use
16+
17+
Use LangChain when you need to:
18+
- **Build tool-calling agents** with `create_agent()` and a prebuilt agent loop
19+
- **Switch model providers** without changing application code via `init_chat_model()`
20+
- **Add structured output** to parse LLM responses into typed objects
21+
- **Integrate with any model or tool** using LangChain's provider packages
22+
- **Use middleware** for cross-cutting concerns like rate limiting and caching
23+
24+
## When NOT to use
25+
26+
- For complex multi-step workflows with custom control flow, use [LangGraph](https://docs.langchain.com/oss/langgraph/overview) instead
27+
- For a batteries-included agent with planning, subagents, and context management, use [Deep Agents](https://docs.langchain.com/oss/deepagents/overview) instead
28+
- LangChain provides the **core building blocks**; LangGraph adds orchestration; Deep Agents adds high-level capabilities on top
29+
30+
## Install
31+
32+
```bash
33+
# Python
34+
pip install -U langchain
35+
36+
# JavaScript/TypeScript
37+
npm install langchain @langchain/core
38+
```
39+
40+
Install a provider integration:
41+
42+
```bash
43+
# Python
44+
pip install -U langchain-openai # or langchain-anthropic, langchain-google-genai
45+
46+
# JavaScript/TypeScript
47+
npm install @langchain/openai # or @langchain/anthropic, @langchain/google-genai
48+
```
49+
50+
## Quick reference
51+
52+
### Create an agent
53+
54+
```python
55+
from langchain.agents import create_agent
56+
57+
def get_weather(city: str) -> str:
58+
"""Get weather for a given city."""
59+
return f"It's always sunny in {city}!"
60+
61+
agent = create_agent(
62+
model="openai:gpt-5.4",
63+
tools=[get_weather],
64+
system_prompt="You are a helpful assistant",
65+
)
66+
67+
result = agent.invoke(
68+
{"messages": [{"role": "user", "content": "What is the weather in SF?"}]}
69+
)
70+
```
71+
72+
### Initialize a chat model
73+
74+
```python
75+
from langchain.chat_models import init_chat_model
76+
77+
# Switch providers by changing the string
78+
model = init_chat_model("openai:gpt-5.4")
79+
model = init_chat_model("anthropic:claude-opus-4-6")
80+
model = init_chat_model("google_genai:gemini-2.5-flash-lite")
81+
```
82+
83+
### Define a tool
84+
85+
```python
86+
from langchain.tools import tool
87+
88+
@tool
89+
def search(query: str) -> str:
90+
"""Search the web for information."""
91+
return "search results"
92+
```
93+
94+
## Gotchas
95+
96+
1. **Snake_case tool names**—Tool function names must be valid Python identifiers. Use `get_weather`, not `get-weather`.
97+
2. **Reserved parameters**—Do not name tool parameters `type`, `name`, or `description` as these conflict with the tool schema.
98+
3. **Provider packages**—Models live in separate packages (e.g., `langchain-openai`). The base `langchain` package does not include providers.
99+
4. **Model string format**—Use `"provider:model-name"` format with `init_chat_model()` (e.g., `"openai:gpt-5.4"`).
100+
101+
## Key documentation
102+
103+
- [Overview](https://docs.langchain.com/oss/langchain/overview)—What LangChain is and how to get started
104+
- [Quickstart](https://docs.langchain.com/oss/langchain/quickstart)—Build your first agent
105+
- [Agents](https://docs.langchain.com/oss/langchain/agents)—Prebuilt agent architecture
106+
- [Models](https://docs.langchain.com/oss/langchain/models)—Chat models and provider integrations
107+
- [Tools](https://docs.langchain.com/oss/langchain/tools)—Define and use tools
108+
- [Structured output](https://docs.langchain.com/oss/langchain/structured-output)—Parse LLM responses into typed objects
109+
- [MCP integration](https://docs.langchain.com/oss/langchain/mcp)—Use Model Context Protocol servers as tools
110+
111+
## API reference
112+
113+
For SDK class and method details, use the [LangChain API Reference](https://reference.langchain.com) site:
114+
- Browse: `https://reference.langchain.com/python/langchain-core`
115+
- MCP server: `https://reference.langchain.com/mcp`
116+
117+
## Related skills
118+
119+
- **langgraph**—Low-level orchestration for stateful, durable agent workflows
120+
- **deep-agents**—Batteries-included agent harness built on LangChain
121+
- **langsmith**—Trace, evaluate, and deploy your LangChain agents

‎src/.mintlify/skills/langgraph/SKILL.md‎

Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
---
2+
name: langgraph
3+
description: Build stateful, durable agent workflows with LangGraph. Use when you need custom graph-based control flow, human-in-the-loop, persistence, or multi-agent orchestration.
4+
license: MIT
5+
compatibility: Python 3.10+, Node.js 20+
6+
metadata:
7+
author: langchain-ai
8+
version: "1.0"
9+
---
10+
11+
# LangGraph
12+
13+
LangGraph is a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents. It provides durable execution, streaming, human-in-the-loop interactions, and time-travel debugging.
14+
15+
## When to use
16+
17+
Use LangGraph when you need to:
18+
- **Design custom agent workflows** with explicit graph-based control flow
19+
- **Add durable execution** so agents survive failures and restarts
20+
- **Implement human-in-the-loop** with interrupts and approval steps
21+
- **Build multi-agent systems** with state shared across agents
22+
- **Stream intermediate results** from long-running agent tasks
23+
- **Time-travel debug** by replaying agent execution from any checkpoint
24+
25+
## When NOT to use
26+
27+
- For a simple tool-calling agent, use [LangChain](https://docs.langchain.com/oss/langchain/overview) agents instead—less boilerplate for common patterns
28+
- For a batteries-included agent with planning and subagents, use [Deep Agents](https://docs.langchain.com/oss/deepagents/overview) instead
29+
- LangGraph is the **orchestration layer**—use it when you need fine-grained control over agent behavior
30+
31+
## Install
32+
33+
```bash
34+
# Python
35+
pip install -U langgraph
36+
37+
# JavaScript/TypeScript
38+
npm install @langchain/langgraph @langchain/core
39+
```
40+
41+
## Quick reference
42+
43+
### Graph API (recommended for most use cases)
44+
45+
```python
46+
from langgraph.graph import StateGraph, MessagesState, START, END
47+
48+
def my_node(state: MessagesState):
49+
return {"messages": [{"role": "ai", "content": "hello world"}]}
50+
51+
graph = StateGraph(MessagesState)
52+
graph.add_node(my_node)
53+
graph.add_edge(START, "my_node")
54+
graph.add_edge("my_node", END)
55+
graph = graph.compile()
56+
57+
result = graph.invoke(
58+
{"messages": [{"role": "user", "content": "Hello!"}]}
59+
)
60+
```
61+
62+
### Functional API (for simple pipelines)
63+
64+
```python
65+
from langgraph.func import entrypoint, task
66+
67+
@task
68+
def step_one(input: str) -> str:
69+
return f"processed: {input}"
70+
71+
@entrypoint()
72+
def pipeline(input: str) -> str:
73+
return step_one(input).result()
74+
```
75+
76+
### Add human-in-the-loop
77+
78+
```python
79+
from langgraph.types import interrupt
80+
81+
def human_approval(state: MessagesState):
82+
answer = interrupt({"question": "Approve this action?"})
83+
return {"messages": [{"role": "user", "content": answer}]}
84+
```
85+
86+
## Key concepts
87+
88+
| Concept | Description |
89+
|---------|-------------|
90+
| `StateGraph` | Define nodes and edges that form your agent's control flow |
91+
| `MessagesState` | Built-in state schema for chat-based agents |
92+
| `compile()` | Compile a graph builder into an executable graph |
93+
| `interrupt()` | Pause execution and wait for human input |
94+
| Checkpointer | Persist state for durable execution and time-travel |
95+
| Graph API vs Functional API | Graph API for complex workflows; Functional API for linear pipelines |
96+
97+
## Key documentation
98+
99+
- [Overview](https://docs.langchain.com/oss/langgraph/overview)—What LangGraph is and when to use it
100+
- [Quickstart](https://docs.langchain.com/oss/langgraph/quickstart)—Build your first graph
101+
- [Persistence](https://docs.langchain.com/oss/langgraph/persistence)—Add memory and durable execution
102+
- [Interrupts](https://docs.langchain.com/oss/langgraph/interrupts)—Human-in-the-loop patterns
103+
- [Streaming](https://docs.langchain.com/oss/langgraph/streaming)—Stream intermediate results
104+
- [Graph API](https://docs.langchain.com/oss/langgraph/graph-api)—Define nodes, edges, and state
105+
- [Deploy](https://docs.langchain.com/oss/langgraph/deploy)—Deploy to production with LangSmith
106+
107+
## API reference
108+
109+
For SDK class and method details, use the [LangChain API Reference](https://reference.langchain.com) site:
110+
- Browse: `https://reference.langchain.com/python/langgraph`
111+
- MCP server: `https://reference.langchain.com/mcp`
112+
113+
## Related skills
114+
115+
- **langchain**—Core building blocks for models, tools, and simple agents
116+
- **deep-agents**—High-level agent harness built on LangGraph
117+
- **langsmith**—Trace, evaluate, and deploy your LangGraph agents

0 commit comments

Comments
 (0)