langchain-ai/langchain-skills
14 skills89.5k installs10.9k starsGitHub
Install
npx skills add https://github.com/langchain-ai/langchain-skillsSkills in this repo
1Deep Agents Memorydeep-agents-memory is a LangChain Deep Agents skill for solo builders who need real file and memory behavior instead of stuffing everything into the chat window. It explains when to use StateBackend for temporary working files inside one conversation thread, FilesystemBackend for local CLI development, StoreBackend when notes and artifacts must persist after the thread ends, and CompositeBackend when some paths should stay ephemeral while others land in long-term storage. The skill ties those choices to FilesystemMiddleware so agents gain consistent listing, read, write, edit, glob, and grep operations without you implementing storage adapters by hand. Invoke it during build when your Deep Agent starts writing drafts, project notes, or multi-file context that must either disappear at session end or remain available on the next run.9.3kinstalls2Langgraph Fundamentalslanggraph-fundamentals is the baseline skill LangChain maintainers expect you to invoke before any LangGraph implementation. Solo builders shipping agent workflows get a directed-graph mental model: StateGraph as the container, nodes as work units, edges as control flow, and reducers as the contract for merging partial updates. The embedded five-step methodology turns napkin flows into implementable graphs—discrete steps, node categories (LLM, data, action, human input), shared state design, node functions returning partial dicts, then wiring and optional persistence. Without it, agents often emit invalid graphs, skip compile(), mishandle conditional routing, or treat state as a dumping ground for formatted prompts. Use at the start of a new agent feature, when debugging stuck loops, or when adding streaming and retries. Pair with langchain-dependencies for versions and deeper LangChain skills for tools and models. Outcome is compilable, reviewable graph code aligned with current LangGraph docs.8.6kinstalls3Langchain Fundamentalslangchain-fundamentals teaches solo builders shipping AI features how to assemble LangChain agents the way current docs intend: one create_agent() call owns the loop, tool execution, and state, while middleware handles human approval and failure paths. You define capabilities with @tool or tool(), pick models like anthropic:claude-sonnet-4-5, and optionally attach MemorySaver for continuity. The skill is opinionated—when creating LangChain agents you must use create_agent()—which reduces drift from blog posts that still reference retired APIs. Use it while building copilots, internal automations, or customer-facing agents where you need a consistent skeleton before layering retrieval, evals, or deployment.8.3kinstalls4Langgraph Persistencelanggraph-persistence teaches solo builders how LangGraph durably saves graph state at every super-step using checkpointers, how thread_id isolates conversation sequences, and when to use the Store for cross-thread facts and preferences. The skill contrasts short-term thread-scoped memory with long-term user-level memory and provides a checkpointer selection table from InMemorySaver for tests through PostgresSaver for production. It is meant to be invoked whenever a LangGraph project needs resume-after-failure behavior, conversational history, historical state navigation, or correctly scoped persistence inside subgraphs—common requirements for customer-support bots, multi-step research agents, and human-in-the-loop workflows. Following the documented patterns helps you avoid shipping graphs that lose state on crash or conflate threads when scaling concurrent users. Pair it with your existing LangGraph graph-design skills when moving from prototype InMemorySaver to SQLite or Postgres backing stores before Ship.8.1kinstalls5Langchain Raglangchain-rag is an agent skill for solo builders shipping knowledge-backed chat, copilots, or internal tools with LangChain. It walks through the full RAG lifecycle: ingesting sources with document loaders, splitting text for retrieval quality, embedding with OpenAI, and persisting vectors in stores suited to dev versus production. The README contrasts InMemory, FAISS, Chroma, and Pinecone so you can pick local disk-backed iteration or managed cloud search without guessing tradeoffs. Use it when you need a grounded LLM feature—not when you only want a plain completion API. It matters because bad chunking and store choices silently hurt answer quality and cost; this skill keeps the stack coherent from first prototype to a path toward Pinecone-backed deployment.8.1kinstalls6Langgraph Human In The LoopLanggraph-human-in-the-loop is an agent skill for solo builders shipping LangGraph workflows who need execution to stop mid-graph, show structured data to a person or UI, and continue only after explicit approval or correction. It centers on interrupt(value) to pause and surface state, Command(resume=value) to feed the answer back into the graph, and the pairing of a checkpointer with a stable thread_id so paused runs are identifiable across invoke and stream calls. The skill stresses operational details that bite in production: JSON-serializable interrupt payloads, InMemorySaver versus PostgresSaver choices, and the fact that resuming re-executes the node from the beginning rather than jumping to the line after interrupt(). It also points you toward structured approval and validation patterns plus a documented four-tier error handling approach when humans are in the loop. Install it when your agent must not auto-commit sensitive actions, when compliance needs an audit trail of pauses, or when you are debugging graphs that silently skip human steps.7.9kinstalls7Deep Agents OrchestrationDeep Agents Orchestration is an agent skill for solo builders shipping LangChain-based Deep Agents who need predictable multi-step behavior without reinventing delegation, planning, and approvals. The skill explains how SubAgentMiddleware exposes a task tool so the main agent can hand complex or tool-heavy work to specialized subagents—including a default general-purpose subagent or custom profiles such as a paper-search researcher. TodoListMiddleware adds write_todos for explicit task planning and progress tracking, while HumanInTheLoopMiddleware gates sensitive operations behind human approval interrupts. Invoke it whenever you are wiring subagents, structured plans, or HITL into a Deep Agent rather than bolting ad-hoc prompts. The content is procedural integration knowledge aligned with create_deep_agent(), making it best for indie developers building internal copilots, research agents, or customer-facing assistants that must isolate context and enforce oversight.7.6kinstalls8Langchain MiddlewareLangchain-middleware is an agent skill for solo and indie builders shipping LangChain or LangGraph assistants that must pause before irreversible actions. It documents HumanInTheLoopMiddleware for gating dangerous tool calls (for example send_email), explains why a checkpointer and thread_id are mandatory, and shows how to resume with Command after approve, edit, or reject. It also covers authoring custom middleware for retries and logging and aligning structured outputs with Pydantic or Zod. Install it when your agent already has tools but lacks production guardrails—not when you only need a one-off script without an agent loop.7.5kinstalls9Deep Agents Coredeep-agents-core is the entry skill for anyone building on LangChain’s Deep Agents framework. It documents the harness architecture—task planning via todos, filesystem tools, subagent delegation, persistent Store memory, human approval gates, and lazy-loaded SKILL.md capabilities—so you configure middleware rather than reimplementing agent infrastructure. The skill includes a clear decision guide: reach for Deep Agents when work is multi-step, context exceeds one prompt, you need specialist subagents, or sessions must remember state; stick with create_agent for narrow, ephemeral jobs. Middleware selection notes explain which layer to enable or tune for planning, files, delegation, and safety. For solo builders shipping agent products or internal coding agents, this is the canonical Build-phase reference before you add persistence specifics or custom skills.7.5kinstalls10Langchain Dependencieslangchain-dependencies answers which packages and versions belong in a fresh LangChain-ecosystem project before agents write imports. Indie builders often mix LangChain 0.x snippets, optional community wheels, and both LangGraph and Deep Agents—then hit subtle breakage. This skill centralizes LTS policy (LangChain 1.0 for new work), the rule that langchain-core always rides along, and the warning that langchain-community does not semver cleanly. It maps Python 3.10+ and Node requirements and explains splitting provider integrations so you only install the vector store and model packages you need. Framework choice is explicit: LangGraph and Deep Agents are alternatives for orchestration, not a forced stack. Invoke at repo init, when asked how to install LangGraph or LangSmith, or before upgrades. Outcome is a predictable lockfile or package.json and fewer incompatible transitive deps—usually as the step immediately before langgraph-fundamentals or other LangChain implementation skills.7.4kinstalls11Framework Selectionframework-selection is the LangChain ecosystem entry skill: it walks solo builders through whether LangChain foundations, LangGraph orchestration, or Deep Agents’ higher-level planning and memory fit the job—or how to combine layers without painting yourself into a corner. You should load it at the very start of any LangChain/LangGraph/Deep Agents effort, before picking companion skills or writing nodes, tools, or graphs. The SKILL.md frames the three frameworks as stacked capabilities rather than competing brands, so the agent recommends the minimum layer that satisfies planning, persistence, loops, and file/memory requirements. Getting this right early prevents rework when a simple chain needs graph state or when a graph should have been a Deep Agent with built-in skills. After a clear choice, invoke the stack-specific skills that match your answers in the decision guide.7.3kinstalls12SwarmThe swarm skill packages implementation guidance for solo builders running LangChain-style swarm or multi-subagent workflows over tabular or row-oriented inputs. It focuses on how to slice work into dispatch batches so you respect a maximum subagent budget while still processing large lists. Auto mode derives a uniform batch size from total rows and maxSubagents; uniform mode fixes one size for every row; per-row mode evaluates a function per record, groups rows that share the same size, then chunks each group. Every resolved size passes through clampBatchSize so nothing exceeds MAX_BATCH_SIZE of fifty or drops below one. Utilities like createBatches, readColumn, and extractPlaceholders tie spreadsheet-like inputs to repeatable agent fan-out. Use it when a single orchestrator must launch parallel subagents over hundreds of items, when you need predictable concurrency instead of naive one-row-one-process spikes, or when you are extending langchain-skills swarm examples in your own graph.774installs13Langgraph CliLangGraph CLI is an agent skill for solo builders building LangChain LangGraph applications who need one reference for scaffolding, local development, container builds, and LangGraph Platform deployment. It explains when to install `langgraph-cli[inmem]` versus the slim CLI, how UV and pip installs differ, and how `langgraph.json` ties dev, build, up, and deploy together. Use it during Build when standing up a new graph project or tuning config, during Ship when you Dockerize and validate compose setups, and during Operate when you manage LangSmith deployments and logs. The skill maps each user intent—new project, edit config, ship to platform—to the right command so you are not guessing flags across Python packaging and deployment docs.637installs14Managed Deep Agentsmanaged-deep-agents documents how solo builders and small teams operate LangSmith’s private-preview Managed Deep Agents API—a hosted runtime that packages the open-source Deep Agents harness with durable threads, streamed runs, managed file trees, and MCP credential storage. Invoke it when you are deciding between this API-first path and self-hosting, when creating or patching agents, registering MCP tools, configuring human-in-the-loop interrupts per tool, or debugging the agent → MCP → thread → run pipeline. The skill expects a LangSmith API key and a modern HTTP client (httpx or fetch). It is intermediate-to-advanced because you must reason about tool graphs, interrupts, and deployment tradeoffs without a local-only sandbox. Outcomes are operational: agents that run in LangSmith with less bespoke server code than a full Agent Server deployment. Pair with langgraph-cli knowledge when users need fully self-hosted control planes.622installs