New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Langchain Tool Builder

by simbajigege in simbajigege/book2skills

Build LangChain (Python) tools using Claude Code's fail-closed design pattern — unified name/schema/security/execution in one class, with automatic three-layer execution (validate → permission →…

MITAuto-check passedAI & LLM Engineering

Install Langchain Tool Builder

skills CLI
$ npx skills add simbajigege/book2skills --skill langchain-tool-builder -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install simbajigege/book2skills langchain-tool-builder --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/simbajigege/book2skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/langchain-tool-builder .claude/skills/langchain-tool-builder && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
langchain-tool-builder
GitHub stars
183
Token cost
~2.3k tokens
SKILL.md length
628 words
Files
7
Skills in repo
37
Repo updated
First seen
Licence
MIT

At a glance

Build LangChain (Python) tools using Claude Code's fail-closed design pattern — unified name/schema/security/execution in one class, with automatic three-layer execution (validate → permission →…

  • Works in 4 steps: Install the base class → Interview the user → Generate the tool file → …
  • The user wants to define a new LangChain tool
  • SKILL.md covers Why this pattern matters, Workflow, Output template and Using build_tool() for simple…, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Langchain Tool Builder is an agent skill from simbajigege/book2skills. Build LangChain (Python) tools using Claude Code's fail-closed design pattern — unified name/schema/security/execution in one class, with automatic three-layer execution (validate → permission → call). Use this skill whenever the user wants to define a new LangChain tool, add permission or validation logic to an existing tool, set up the ClaudeStyleTool base class in a project, or asks about "buildtool", "Claude Code style tool", "工具定义", or "langchain tool with permissions". Also trigger when the user says…

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 9 other files (for example `README.md`, `en/langchain-tool-builder.md` and `examples/en.yaml`).

It sits in AI & LLM Engineering, covering Building AI agents. It works with LangChain and Python. The repository describes itself as: Create best skills based on best books. The licence is MIT.

When your agent uses it

  • The user wants to define a new LangChain tool
  • Validation logic to an existing tool
  • Set up the ClaudeStyleTool base class in a project
  • Asks about buildtool

Example prompts

  • “buildtool”
  • “Claude Code style tool”
  • “langchain tool with permissions”
  • “/langchain-tool-builder”

Requirements

  • Python 3

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Install the base class
  2. Interview the user
  3. Generate the tool file
  4. Show security property summary

What it can do on your machine

Read from SKILL.md and the folder at commit e5ba66c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are python).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Langchain Tool Builder loads about 2.3k tokens when it runs. Until then it costs about 164 tokens; SKILL.md has 628 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~164
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from simbajigege/book2skills at commit e5ba66c, republished under its MIT licence (© simbajigege). 628 words, ~2,321 tokens.

Download SKILL.mdSave it as .claude/skills/langchain-tool-builder/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
langchain-tool-builder
description
Build LangChain (Python) tools using Claude Code's fail-closed design pattern — unified name/schema/security/execution in one class, with automatic three-layer execution (validate → permission → call). Use this skill whenever the user wants to define a new LangChain tool, add permission or validation logic to an existing tool, set up the ClaudeStyleTool base class in a project, or asks about "build_tool", "Claude Code style tool", "工具定义", or "langchain tool with permissions". Also trigger when the user says "create a tool for X" or "定义一个工具" in a LangChain Python project context, even without mentioning Claude Code explicitly.

LangChain Tool Builder

Helps define LangChain (Python) tools using Claude Code's buildTool() pattern: a unified class that co-locates identity, schema, security properties, and execution logic, with fail-closed defaults so new tools are safe by default.

Why this pattern matters

Claude Code enforces three things that vanilla LangChain tools lack:

  1. Fail-closed defaults — is_read_only, is_destructive, is_concurrency_safe all default to False. A tool that forgets to declare its properties is conservatively treated as write-capable.
  2. Layered execution — validate_semantics → check_permissions → _call are separate methods, so validation logic doesn't bleed into permission logic or business logic.
  3. Self-contained definition — schema, description, security metadata, and execution all live in one class. No separate permission middleware to wire up.

Workflow

Step 1 — Install the base class

Check if claude_style_tool.py exists in the project's utils directory. The expected location for the ai-base project is: /Users/jigege/ai-base/backend/base/utils/claude_style_tool.py

If it doesn't exist, copy it from references/claude_style_tool.py in this skill directory. Tell the user where it was placed and what it provides.

If working in a different project, ask the user where their utils/tools directory is.

Step 2 — Interview the user

Collect answers to these questions. Defaults are shown — skip questions where the default is clearly fine.

Naming convention: use {service}_{action}_{resource} format with a service prefix so the tool stays unambiguous when multiple tool sets are loaded simultaneously (e.g. stock_get_price, stock_list_symbols, github_create_issue). Start with a verb: get, list, search, create, delete.

FieldQuestionDefault
name工具名（格式：{service}_{action}_{resource}，例如 stock_get_price）— required
description给 LLM 看的一句话描述：精确匹配实际功能，不要模糊扩大，否则 agent 会在不该用的场景误调用— required
Schema fields工具接受哪些参数？（字段名、类型、说明；在 Field description 里加 example，如 e.g. '2024-01-01'）— required
is_read_only这个工具只读数据，不写入/不产生副作用吗？False
is_destructive这个工具会做不可逆操作（删除、覆盖）吗？False
is_concurrency_safe这个工具可以和其他工具同时运行吗？False
response_format返回数据是给 agent 程序化处理（JSON）还是给用户展示（Markdown）？视场景，默认 Markdown
是否列表工具如果返回多条记录，要支持分页吗？超过 50 条建议加
_validate_input_semantics有没有需要在执行前拦截的语义问题？（如：参数太短、路径格式不对）不需要
_check_permissions有没有需要检查的权限？（如：只允许读特定路径、需要某个 env var）不需要
_call工具的核心执行逻辑是什么？— required

You don't have to ask all questions upfront — you can infer reasonable answers from context. For example, a "search" tool is almost certainly is_read_only=True, is_concurrency_safe=True.

Step 3 — Generate the tool file

Create a .py file for the tool. Follow this field order (matches Claude Code's BashTool):

1. imports
2. Input schema (Pydantic BaseModel)
3. Tool class:
   a. name, description, args_schema      — identity
   b. is_read_only, is_destructive, is_concurrency_safe, max_result_chars  — security metadata
   c. _validate_input_semantics()         — semantic validation (omit if unneeded)
   d. _check_permissions()               — permission check (omit if unneeded)
   e. _call()                            — actual logic

Suggest a file path consistent with the project's tool/agent directory structure. For ai-base, suggest: /Users/jigege/ai-base/backend/base/tools/<tool_name>.py

Step 4 — Show security property summary

After generating, print a one-line summary of the tool's security posture:

SearchDocsTool: read_only=True  destructive=False  concurrency_safe=True  max_result=10K

This helps the user quickly verify the fail-closed properties are set correctly.

Show full SKILL.md (253 more words)Show less

Output template

Use this structure when generating the tool file. Adjust based on what the user actually needs.

python
"""<tool_name>.py — <one-line description>"""

from typing import Optional
from pydantic import BaseModel, Field
from base.utils.claude_style_tool import ClaudeStyleTool


# ---------------------------------------------------------------------------
# Input schema
# ---------------------------------------------------------------------------

class <ToolName>Input(BaseModel):
    <field_name>: <type> = Field(description="<description>")
    # ... more fields


# ---------------------------------------------------------------------------
# Tool class
# ---------------------------------------------------------------------------

class <ToolName>Tool(ClaudeStyleTool):
    # — identity —
    name: str = "<tool_name>"
    description: str = "<one-sentence description for the LLM>"
    args_schema = <ToolName>Input

    # — security metadata (fail-closed: only set True when verified) —
    is_read_only: bool = <True/False>
    is_destructive: bool = <True/False>
    is_concurrency_safe: bool = <True/False>
    max_result_chars: int = 10_000

    # — semantic validation (omit if no input constraints needed) —
    def _validate_input_semantics(self, <params>) -> tuple[bool, Optional[str]]:
        if not <condition>:
            # Error messages must be actionable: tell the agent WHAT to do next
            return False, "<why invalid>. Try <concrete fix, e.g. 'use filter=active_only'>"
        return True, None

    # — permission check (omit if no access control needed) —
    def _check_permissions(self, <params>) -> tuple[bool, Optional[str]]:
        if not <allowed>:
            return False, "<why denied>. <suggested next step>"
        return True, None

    # — core logic —
    def _call(self, <params>, **kwargs) -> str:
        # ... implement tool logic here
        return result

Using build_tool() for simple tools

When the tool has no custom validation or permission logic, build_tool() is cleaner:

python
from base.utils.claude_style_tool import build_tool
from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search query string")

search_tool = build_tool(
    name="search_docs",
    description="Search the documentation index for relevant content.",
    args_schema=SearchInput,
    call_fn=lambda query, **_: search_index(query),
    is_read_only=True,
    is_concurrency_safe=True,
)

Common security property patterns

Tool typeis_read_onlyis_destructiveis_concurrency_safe
搜索 / 查询TrueFalseTrue
文件读取TrueFalseTrue
文件写入 / 修改FalseFalseFalse
删除操作FalseTrueFalse
API 调用（GET）TrueFalseTrue
API 调用（POST/DELETE）False视情况False
数据库查询TrueFalseTrue
数据库写入FalseFalseFalse

Output design principles

Atomic tools — one tool, one responsibility

Keep each tool focused on a single operation. Let the agent compose multiple tools to complete complex tasks. A tool that does too much is harder for the agent to reuse and reason about.

Response format — JSON vs Markdown
FormatWhen to use
JSONAgent needs to parse/filter the result programmatically
MarkdownResult will be shown directly to a user

Support both when uncertain — accept an optional response_format: str = "markdown" parameter and branch in _call. For JSON output use json.dumps(data, ensure_ascii=False, indent=2).

Pagination for list tools

Any tool that can return more than ~50 records should support pagination. Return a dict with these fields so the agent knows when to continue fetching:

python
return json.dumps({
    "items": [...],
    "total": 150,
    "count": 20,
    "offset": 0,
    "has_more": True,
    "next_offset": 20,
}, ensure_ascii=False, indent=2)

Add offset: int = Field(default=0, description="Pagination offset") and limit: int = Field(default=20, description="Max items to return, default 20") to the input schema.

Actionable error messages

Error strings returned from _validate_input_semantics and _check_permissions must guide the agent toward a fix — not just describe the failure:

python
# Bad: agent is stuck
return False, "Query too short."

# Good: agent knows exactly what to try next
return False, "Query too short (got 2 chars, need ≥ 3). Provide a more specific search term."

Reference files

  • references/claude_style_tool.py — 完整的 ClaudeStyleTool 基类和 build_tool() 工厂函数 安装路径：/Users/jigege/ai-base/backend/base/utils/claude_style_tool.py

© simbajigege, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files in skills/langchain-tool-builder of simbajigege/book2skills.

  • SKILL.md
  • LICENSE
  • README.md
  • en/langchain-tool-builder.md
  • examples/en.yaml
  • examples/zh.yaml
  • zh/langchain-tool-builder.md

Open the folder on GitHubat commit e5ba66c

Compare with similar skills

Langchain Tool Builder next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Langchain Tool Builder compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Langchain Tool Builder this skillsimbajigege/book2skills183—~2.3kAutomated safety check: PassMIT
Add Example AgentGetBindu/Bindu10k—~1.1kAutomated safety check: NotesCustom licence
Failproof AI SDK IntegrationFailproofAI/failproofai5.3k—~6kAutomated safety check: PassCustom licence
Omnigent Framework Detectionomnigent-ai/omnigent11k—~610Automated safety check: PassApache-2.0
Upgrade Stripekanchengw/cnllm1733 repos~1.4kAutomated safety check: PassApache-2.0
Deep Agents to Pydantic AI Migrationpydantic/pydantic-ai21k—~1.7kAutomated safety check: PassMIT

Similar skills

  • Add Example Agent

    GetBindu/Bindu

    Add a new self-contained example agent under examples/. An agent skill from GetBindu/Bindu.

    10k GitHub stars~1.1k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check: notes

  • Failproof AI SDK Integration

    FailproofAI/failproofai

    Helps instrument a custom Python or TypeScript agent to record events for Failproof AI, verify what gets written, and run an evaluator worker that scores the runs.

    5.3k GitHub stars~6k tokensUpdated 3 days ago
    AI & LLM EngineeringAuto-check passed

  • Omnigent Framework Detection

    omnigent-ai/omnigent

    Scans Python agent code for framework imports and recommends the matching Omnigent executor type, or says when the framework is not natively supported yet.

    11k GitHub stars~610 tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • Upgrade Stripe

    kanchengw/cnllm

    Guide for upgrading Stripe API versions and SDKs. An agent skill from kanchengw/cnllm.

    173 GitHub starsUsed in 3 repos~1.4k tokens
    AI & LLM EngineeringAuto-check passed

  • Deep Agents to Pydantic AI Migration

    pydantic/pydantic-ai

    Official

    Migrates Python LangChain Deep Agents applications to Pydantic AI and Pydantic AI Harness while preserving the application's observed behavior.

    21k GitHub stars~1.7k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • Add Docs Page

    langchain-ai/docs

    Official

    Add, move, rename, or delete a page on the LangChain docs site.

    426 GitHub stars~2k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

More from simbajigege/book2skills

All 37 skills in this repo

  • MEMORY.md Restructuring

    simbajigege/book2skills

    Reorganizes an overgrown MEMORY.md into a short pointer index plus separate topic files, and fixes or deletes outdated memories instead of archiving them.

    183 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed

  • Compact Memory Implementation

    simbajigege/book2skills

    A developer guide to adding compact memory to an agent: when to trigger compaction, how to fork a compactor sub-agent, what the summary holds, and how to restore it.

    183 GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check passed

  • Semantic Line-Art SVG Diagrams

    simbajigege/book2skills

    Turns text, screenshots, or existing diagrams into minimal, accessible line-art SVGs for teaching material, with an optional Mermaid relationship spec.

    183 GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check passed

  • Fail-Closed Agent Tool Builder

    simbajigege/book2skills

    Helps define agent tools with a fail-closed pattern: one class holding name, schema, security flags and a validate, permission and call execution chain.

    183 GitHub stars~2k tokensUpdated 1 mo ago
    Auto-check passed

  • LLM Query Loop Implementation

    simbajigege/book2skills

    Implements a production-style agent loop in your own AI product, with tool calling, tool results fed back, exit conditions and budget guards.

    183 GitHub stars~1.4k tokensUpdated 1 mo ago
    Auto-check passed

  • Tool Permission System Design

    simbajigege/book2skills

    Guides designing a layered permission pipeline for agent tools that decides which calls are allowed, need confirmation or are denied, with scopes and hooks.

    183 GitHub stars~2.1k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Langchain Tool Builder

What does Langchain Tool Builder do?

Build LangChain (Python) tools using Claude Code's fail-closed design pattern — unified name/schema/security/execution in one class, with automatic three-layer execution (validate → permission →…. Langchain Tool Builder is an agent skill from simbajigege/book2skills. Build LangChain (Python) tools using Claude Code's fail-closed design pattern — unified name/schema/security/execution in one class, with automatic three-layer execution (validate → permission → call).

When should I use Langchain Tool Builder?

Langchain Tool Builder fits situations like: the user wants to define a new LangChain tool; validation logic to an existing tool; set up the ClaudeStyleTool base class in a project; asks about buildtool.

How do I install Langchain Tool Builder in Claude Code?

Run `npx skills add simbajigege/book2skills --skill langchain-tool-builder -a claude-code`. Or copy the skill folder (skills/langchain-tool-builder in simbajigege/book2skills) into .claude/skills/langchain-tool-builder in your project. Claude Code loads it when a task matches its description.

How do I install Langchain Tool Builder in Codex?

Run `npx skills add simbajigege/book2skills --skill langchain-tool-builder -a codex`. Or copy the skill folder (skills/langchain-tool-builder in simbajigege/book2skills) into .agents/skills/langchain-tool-builder in your project. Codex loads it when a task matches its description.

Can I use Langchain Tool Builder in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add simbajigege/book2skills --skill langchain-tool-builder -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/langchain-tool-builder, .gemini/skills/langchain-tool-builder, .github/skills/langchain-tool-builder and .opencode/skills/langchain-tool-builder in your project.

What does Langchain Tool Builder need to run?

SKILL.md names no scripts, command-line tools or credentials: Langchain Tool Builder is instructions for the agent only. Our summary lists: Python 3.

Does Langchain Tool Builder access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Langchain Tool Builder safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Langchain Tool Builder use?

Langchain Tool Builder is published under the MIT licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Langchain Tool Builder use?

About 2.3k tokens (SKILL.md is roughly 9.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Langchain Tool Builder?

Skills that share tags, products or a category with Langchain Tool Builder: Add Example Agent (GetBindu/Bindu, 10k stars), Failproof AI SDK Integration (FailproofAI/failproofai, 5.3k stars), Omnigent Framework Detection (omnigent-ai/omnigent, 11k stars) and Upgrade Stripe (kanchengw/cnllm, 173 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Langchain Tool Builder?

simbajigege (a GitHub user) maintains it in simbajigege/book2skills, which has 183 GitHub stars. The repository holds 37 skills in this directory. The repository was last updated on August 26, 2026.

Source: simbajigege/book2skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.