langchain-agents-workflow

DevOps Community

Repo stars 0
Author repo skills-registry

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: Use when starting work on any LangChain / LangGraph / DeepAgents project. Entry point for the develop -> middleware -> evaluate…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “Version floors this bundle assumes”, “You have two complementary tools”, “When to load which skill”, “Mental model”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name langchain-agents-workflow directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “Version floors this bundle assumes / You have two complementary tools / When to load which skill” before expanding.

Boundaries And Review

Dependencies: Prepare OpenAI / Anthropic API keys before running a full task.
Permissions: Declared permissions include read / write / env-read; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

LangChain Agents Workflow

This skill is the entry point — read it first, then load the more specific skill for the step you're on.

Version floors this bundle assumes

langchain >= 1.2 (v1 series — middleware-first create_agent)
langgraph >= 1.1, langgraph-cli >= 0.4
deepagents >= 0.5.3 (async sub-agents, structured sub-agent responses, filesystem permissions; model=None deprecated)
langsmith >= 0.7 (pytest plugin + new evaluator API)
langchain-anthropic >= 1.4, langchain-openai >= 1.0

If a project pins anything below these floors, suggest the bump before writing code — the API shapes in this bundle assume the v1+ surface.

You have two complementary tools

This skill bundle pairs with the mcpdoc MCP server. The two have distinct roles; use both.

	`mcpdoc` (MCP server)	This skill bundle
Purpose	Live API reference	Opinionated playbook
Content	Whatever's on `docs.langchain.com` right now	How to think about LangChain projects
When to use	"What's the signature of `SummarizationMiddleware`?" / "What kwargs does `create_agent` take?" / "What import path for X?"	"What's the production middleware stack?" / "How do I wire Cloud Run + Secret Manager + Postgres checkpointer together?" / "Which mistakes does an agent typically make here?"
How to use	Call `fetch_docs(url)` or `list_doc_sources()`	Load skills based on description triggers
Drift risk	Zero — always live	Owner updates as ecosystem evolves; some rot tolerated

Rule of thumb: when you need an exact API detail, fetch from mcpdoc. When you need to make a design decision, load a skill. When in doubt, do both.

When to load which skill

Goal	Skill
Start a new agent project	`langchain-agents-scaffold`
Build a modern agent (most cases)	`langchain-agents-middleware` ← first; uses `create_agent(...)` with middleware
Add nodes/edges/tools to a custom LangGraph	`langchain-agents-langgraph-code`
Customize a DeepAgent	`langchain-agents-deepagents-code`
Build a non-agentic LCEL pipeline (chains, RAG)	`langchain-agents-langchain-code`
Write or run evals; unit/integration test agents	`langchain-agents-langsmith-evals`
Deploy + productionise	`langchain-agents-deploy`
Debug / read traces / OTEL	`langchain-agents-observability`

Mental model

Three layers in the modern stack:

create_agent(model, tools, middleware=...) — the v1 default for building agents. Middleware is how you add retries, fallbacks, summarization, HITL, PII handling, call limits. Read the middleware skill for the production stack.
Raw LangGraph (StateGraph) — drop down when create_agent isn't enough (multi-graph workflows, custom state, parallel branches). Read langgraph-code.
DeepAgents — create_deep_agent(...) is create_agent(...) pre-loaded with FilesystemMiddleware + SubAgentMiddleware + TodoListMiddleware. Read deepagents-code.

For non-agentic flows (RAG, classification), use plain LCEL chains — middleware does not apply to chains.

Common commands by lifecycle stage

Stage	Command(s)
Scaffold a LangGraph project	`langgraph new my-agent --template react-agent`
Scaffold a DeepAgent / chain	No scaffolder — write a small `agent.py` (see scaffold skill)
Install deps	`pip install -e .` or `uv sync`
Iterate on a graph	`langgraph dev`
Run an agent ad hoc	`python -c "from agent.agent import agent; print(agent.invoke({'messages': [...] }))"`
Run evals	`python evals/run.py`
Unit-test agents (no API calls)	`pytest` with `LLMToolEmulator` middleware
Deploy to LangSmith Cloud	`langgraph build -t my-agent && langgraph deploy`
Deploy to Cloud Run	`gcloud run deploy my-agent --source .`
Deploy as a Docker image	`docker build && docker run --env-file .env`

Hard rules

Look up exact APIs via mcpdoc, don't guess. If mcpdoc isn't configured, ask the user to set it up (see this repo's README) before you write LangChain code.
Always check what's already installed before suggesting pip install — pip show langchain langgraph deepagents langsmith.
Never print .env contents — refer to keys by name only.
For ANY production agent, add the production middleware stack (call limits, retries, fallback, summarization). Copy-paste-ready in the middleware skill.
Run smoke evals before any deploy. Not enforced — you must do it.
Read the project structure first (ls, tree -L 2) before assuming layout.

Required environment variables (most projects)

LANGSMITH_API_KEY — for tracing and evals.
LANGSMITH_TRACING=true — enables trace capture.
LANGSMITH_PROJECT — trace bucket name.
One of OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.

If any are missing when needed, fail fast with a clear message that names the missing variable.

Source: cwijayasundara/agent_cli_langchain — distributed by TomeVault.

Fluxly profile Author and license come from source; runtime, permissions, and network are Fluxly detections or estimates

Fluxly category: DevOps
Author-declared agents: No explicit declaration found; this is not inferred or tested compatibility
Static check: 88 / 100 · heuristic scan, not runtime safety proof
Author / version / license: @tomevault-io · no license declared
Fluxly token estimate: Lean
Fluxly setup estimate: Manual integration
External API key: Required · OpenAI / Anthropic
Detected OS requirements: Docker
Runtime requirements: Python · Docker
Detected file/system behavior: Read-only
Write / modify
Env read
Detected network behavior: External requests
Install commands: None (reference only)

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview langchain-agents-workflow.preview

The current SKILL.md does not define a fixed output example.

SKILL.md SKILL.md

# LangChain Agents Workflow

This skill is the entry point — read it first, then load the more specific skill for the step you're on.

## Version floors this bundle assumes

- `langchain >= 1.2` (v1 series — middleware-first `create_agent`)
- `langgraph >= 1.1`, `langgraph-cli >= 0.4`
- `deepagents >= 0.5.3` (async sub-agents, structured sub-agent responses, filesystem permissions; `model=None` deprecated)
- `langsmith >= 0.7` (pytest plugin + new evaluator API)
- `langchain-anthropic >= 1.4`, `langchain-openai >= 1.0`

If a project pins anything below these floors, suggest the bump before writing code — the API shapes in this bundle assume the v1+ surface.

## You have two complementary tools

This skill bundle pairs with the **`mcpdoc` MCP server**. The two have distinct roles; use both.

| | `mcpdoc` (MCP server) | This skill bundle |
|---|---|---|
| Purpose | Live API reference | Opinionated playbook |
| Content | Whatever's on `docs.langchain.com` right now | How to *think* about LangChain projects |
| When to use | "What's the signature of `SummarizationMiddleware`?" / "What kwargs does `create_agent` take?" / "What import path for X?" | "What's the production middleware stack?" / "How do I wire Cloud Run + Secret Manager + Postgres checkpointer together?" / "Which mistakes does an agent typically make here?" |
| How to use | Call `fetch_docs(url)` or `list_doc_sources()` | Load skills based on description triggers |
| Drift risk | Zero — always live | Owner updates as ecosystem evolves; some rot tolerated |

**Rule of thumb:** when you need an exact API detail, fetch from `mcpdoc`. When you need to make a design decision, load a skill. When in doubt, do both.

## When to load which skill

| Goal | Skill |
|---|---|

…

Evidence boundary and execution chain

Author text anchors workflow facts; Fluxly only indexes current sections, terms, files, and commands.

sections -> Version floors this bundle assumes → You have two complementary tools → When to load which skill → Mental model → Common commands by lifecycle stage → Hard rules
terms    -> mcpdoc MCP server · Rule of thumb · createagent(model, tools, middleware=...) · middleware · Raw LangGraph (StateGraph) · langgraph-code · DeepAgents · deepagents-code
files/cmd -> langchain >= 1.2 · createagent · langgraph >= 1.1 · langgraph-cli >= 0.4 · deepagents >= 0.5.3 · model=None · langsmith >= 0.7 · langchain-anthropic >= 1.4
body sha256 -> 3840bea1b7b7