10 LangChain Toolkits: SQL, Playwright, GitHub, Slack (2026)

from langchain_community.agent_toolkits import SQLDatabaseToolkit
from langchain_community.utilities import SQLDatabase
from langchain_openai import ChatOpenAI

db = SQLDatabase.from_uri("sqlite:///example.db")
llm = ChatOpenAI(model="gpt-4o")

toolkit = SQLDatabaseToolkit(db=db, llm=llm)
tools = toolkit.get_tools()

for tool in tools:
    print(f"Tool: {tool.name}")
    print(f"Description: {tool.description[:100]}\n")
# → sql_db_query, sql_db_schema, sql_db_list_tables, sql_db_query_checker

from langchain_community.agent_toolkits import SQLDatabaseToolkit, create_sql_agent
from langchain_community.utilities import SQLDatabase
from langchain_openai import ChatOpenAI
import sqlite3

# Create a test database
conn = sqlite3.connect("sales.db")
cursor = conn.cursor()
cursor.executescript("""
    CREATE TABLE IF NOT EXISTS customers (
        id INTEGER PRIMARY KEY,
        name TEXT,
        email TEXT,
        signup_date DATE,
        plan TEXT
    );
    CREATE TABLE IF NOT EXISTS orders (
        id INTEGER PRIMARY KEY,
        customer_id INTEGER,
        product TEXT,
        amount DECIMAL,
        order_date DATE,
        FOREIGN KEY (customer_id) REFERENCES customers(id)
    );
""")

# Insert sample data
cursor.executemany("INSERT OR IGNORE INTO customers VALUES (?,?,?,?,?)", [
    (1, "Alice Chen", "alice@example.com", "2024-01-15", "enterprise"),
    (2, "Bob Smith", "bob@example.com", "2024-03-20", "starter"),
    (3, "Carol Davis", "carol@example.com", "2025-06-01", "enterprise"),
])
cursor.executemany("INSERT OR IGNORE INTO orders VALUES (?,?,?,?,?)", [
    (1, 1, "Analytics Suite", 2499.00, "2025-01-10"),
    (2, 1, "API Access", 499.00, "2025-03-05"),
    (3, 2, "Basic Plan", 99.00, "2025-04-01"),
])
conn.commit()
conn.close()

# Connect LangChain to the database
db = SQLDatabase.from_uri(
    "sqlite:///sales.db",
    include_tables=["customers", "orders"],  # Whitelist for safety
    sample_rows_in_table_info=3
)

llm = ChatOpenAI(model="gpt-4o", temperature=0)
toolkit = SQLDatabaseToolkit(db=db, llm=llm)

# Create SQL agent
agent_executor = create_sql_agent(
    llm=llm,
    toolkit=toolkit,
    verbose=True,
    agent_type="tool-calling",
    max_iterations=10
)

# Natural language queries
result = agent_executor.invoke({
    "input": "Who are our top 3 customers by total order value? Show their names and total spend."
})
print(result["output"])
# → "The top 3 customers by total order value are:
#    1. Alice Chen: $2,998.00
#    2. Carol Davis: (no orders yet)
#    3. Bob Smith: $99.00"

# Always use read-only credentials in production
db_read_only = SQLDatabase.from_uri(
    "postgresql://readonly_user:password@host/db",
    include_tables=["public.orders", "public.customers"],  # explicit whitelist
    max_string_length=500  # truncate long text fields
)

# pip install langchain-community playwright
# playwright install chromium

import asyncio
from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
from langchain_community.tools.playwright.utils import create_async_playwright_browser
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

async def run_browser_agent():
    # Create browser instance
    async_browser = await create_async_playwright_browser(headless=True)
    
    toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=async_browser)
    tools = toolkit.get_tools()
    
    print("Available browser tools:")
    for tool in tools:
        print(f"  - {tool.name}: {tool.description[:80]}")
    # → navigate_browser, click_element, fill_form_element, get_elements, etc.
    
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a web research assistant with browser access. Navigate websites to find information."),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad")
    ])
    
    agent = create_tool_calling_agent(llm, tools, prompt)
    executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=15)
    
    # Research task
    result = await executor.ainvoke({
        "input": "Go to python.org and find the current Python version. Then go to pypi.org and check the latest version of langchain.",
        "chat_history": []
    })
    
    await async_browser.close()
    return result["output"]

# Run the browser agent
result = asyncio.run(run_browser_agent())
print(result)

import os
from langchain_community.agent_toolkits.github.toolkit import GitHubToolkit
from langchain_community.utilities.github import GitHubAPIWrapper
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

# Set environment variables
os.environ["GITHUB_ACCESS_TOKEN"] = "ghp_your_personal_access_token"
os.environ["GITHUB_REPOSITORY"] = "your-username/your-repo"

# Initialize GitHub toolkit
github_wrapper = GitHubAPIWrapper()
toolkit = GitHubToolkit.from_github_api_wrapper(github_wrapper)
tools = toolkit.get_tools()

print("GitHub tools available:")
for tool in tools:
    print(f"  - {tool.name}")
# → get_issues, get_issue, comment_on_issue, list_open_pull_requests,
#   get_pull_request, create_file, read_file, update_file, list_files_in_main_branch, etc.

llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a GitHub assistant. Help with repository management, code review, and issue tracking.
    When asked to do something that modifies the repository, confirm with the user first."""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8
)

# Example: Code review assistant
result = executor.invoke({
    "input": "List all open pull requests and summarize what changes they contain.",
    "chat_history": []
})
print(result["output"])

# Example: Issue triage
triage_result = executor.invoke({
    "input": "Look at the open issues and categorize them as bug, feature request, or documentation.",
    "chat_history": []
})

import os
from langchain_community.agent_toolkits import SlackToolkit

# Set environment variables
os.environ["SLACK_BOT_TOKEN"] = "xoxb-your-bot-token"

toolkit = SlackToolkit()
tools = toolkit.get_tools()

print("Slack tools:")
for tool in tools:
    print(f"  - {tool.name}: {tool.description[:80]}")
# → get_channel, get_messages_history, send_message, schedule_message, get_guilds

# Build Slack agent
from langchain.agents import AgentExecutor, create_tool_calling_agent

llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a Slack assistant. Help users manage messages, channels, and notifications."),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Send a deployment notification
result = executor.invoke({
    "input": "Send a message to #deployments saying 'Version 2.4.1 deployed successfully to production at 14:30 UTC'",
    "chat_history": []
})

# Read recent messages
read_result = executor.invoke({
    "input": "What are the 5 most recent messages in #general?",
    "chat_history": []
})

from langchain_community.agent_toolkits.jira.toolkit import JiraToolkit
from langchain_community.utilities.jira import JiraAPIWrapper
import os

os.environ["JIRA_API_TOKEN"] = "your-jira-api-token"
os.environ["JIRA_USERNAME"] = "your-email@company.com"
os.environ["JIRA_INSTANCE_URL"] = "https://your-domain.atlassian.net"
os.environ["JIRA_CLOUD"] = "True"

jira_wrapper = JiraAPIWrapper()
toolkit = JiraToolkit.from_jira_api_wrapper(jira_wrapper)
tools = toolkit.get_tools()

# Jira tools: create_issue, search, update_issue, get_projects, etc.

executor = AgentExecutor(
    agent=create_tool_calling_agent(ChatOpenAI(model="gpt-4o"), tools, prompt),
    tools=tools,
    verbose=True
)

result = executor.invoke({
    "input": "Create a high-priority bug ticket in project BACKEND titled 'API response time exceeds 2 seconds on /users endpoint'. Add the description: Observed in production since 2026-05-30. Affects 15% of users.",
    "chat_history": []
})

from langchain_community.agent_toolkits import O365Toolkit
import os

os.environ["O365_CLIENT_ID"] = "your-azure-app-client-id"
os.environ["O365_CLIENT_SECRET"] = "your-azure-app-secret"

toolkit = O365Toolkit()
tools = toolkit.get_tools()

# Tools: send_email, search_email, create_calendar_event, get_events, etc.

executor = AgentExecutor(
    agent=create_tool_calling_agent(ChatOpenAI(model="gpt-4o"), tools, prompt),
    tools=tools,
    verbose=True
)

result = executor.invoke({
    "input": "Schedule a team meeting for tomorrow at 3pm titled 'Q2 Planning Session' and send calendar invites to alice@company.com and bob@company.com",
    "chat_history": []
})

from langchain_community.agent_toolkits import FileManagementToolkit

# Restrict to a specific directory for safety
toolkit = FileManagementToolkit(
    root_dir="./workspace",  # Agent can only access files here
    selected_tools=["read_file", "write_file", "list_directory", "copy_file"]
    # Omit "delete_file" unless you're sure
)

tools = toolkit.get_tools()
# → read_file, write_file, list_directory, copy_file, move_file, delete_file, file_search

executor = AgentExecutor(
    agent=create_tool_calling_agent(ChatOpenAI(model="gpt-4o"), tools, prompt),
    tools=tools,
    verbose=True
)

result = executor.invoke({
    "input": "Read all .txt files in the workspace folder and create a summary file called 'summary.txt' containing a brief description of each file's content.",
    "chat_history": []
})

from langchain_community.agent_toolkits.openapi import planner
from langchain_community.agent_toolkits.openapi.spec import reduce_openapi_spec
from langchain_community.utilities.requests import RequestsWrapper
import yaml
import requests

# Load an OpenAPI spec
spec_url = "https://petstore3.swagger.io/api/v3/openapi.json"
raw_spec = requests.get(spec_url).json()

# Reduce spec (removes excessive description text)
reduced_spec = reduce_openapi_spec(raw_spec)

requests_wrapper = RequestsWrapper(
    headers={"Authorization": "Bearer your-api-token"}
)

llm = ChatOpenAI(model="gpt-4o", temperature=0)

agent = planner.create_openapi_agent(
    api_spec=reduced_spec,
    requests_wrapper=requests_wrapper,
    llm=llm,
    verbose=True
)

result = agent.invoke({
    "input": "Find all available pets with status 'available' and list their names."
})
print(result["output"])

from langchain_experimental.agents import create_pandas_dataframe_agent
from langchain_openai import ChatOpenAI
import pandas as pd
import numpy as np

# Create sample dataset
np.random.seed(42)
df = pd.DataFrame({
    "date": pd.date_range("2025-01-01", periods=100),
    "product": np.random.choice(["Widget A", "Widget B", "Widget C"], 100),
    "region": np.random.choice(["North", "South", "East", "West"], 100),
    "revenue": np.random.normal(5000, 1500, 100).round(2),
    "units": np.random.randint(10, 200, 100)
})

llm = ChatOpenAI(model="gpt-4o", temperature=0)

agent = create_pandas_dataframe_agent(
    llm=llm,
    df=df,
    verbose=True,
    agent_type="tool-calling",
    allow_dangerous_code=True  # Required flag — ensure df contains no sensitive data
)

result = agent.invoke("Which product generates the highest average revenue per unit? Show the calculation.")
print(result["output"])

result2 = agent.invoke("Create a monthly revenue breakdown and identify the best performing month.")
print(result2["output"])

from langchain_community.agent_toolkits import VectorStoreToolkit, VectorStoreInfo
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_core.documents import Document

# Build a knowledge base vector store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

docs = [
    Document(page_content="LangChain supports Python and JavaScript.", metadata={"topic": "langchain"}),
    Document(page_content="Pinecone is a cloud vector database.", metadata={"topic": "vector-db"}),
    Document(page_content="RAG improves LLM accuracy on specific domains.", metadata={"topic": "rag"}),
]

vectorstore = Chroma.from_documents(docs, embeddings, collection_name="knowledge_base")

# Define vector store info for the agent
vectorstore_info = VectorStoreInfo(
    name="company_knowledge_base",
    description="Company knowledge base covering AI tools, APIs, and best practices. Use this to answer questions about company technology stack.",
    vectorstore=vectorstore
)

toolkit = VectorStoreToolkit(
    vectorstore_info=vectorstore_info,
    llm=ChatOpenAI(model="gpt-4o")
)

tools = toolkit.get_tools()
# → company_knowledge_base_search (semantic search)
# → company_knowledge_base_search_with_relevance_scores

executor = AgentExecutor(
    agent=create_tool_calling_agent(ChatOpenAI(model="gpt-4o"), tools, prompt),
    tools=tools,
    verbose=True
)

result = executor.invoke({
    "input": "What vector databases do we use and why?",
    "chat_history": []
})

from langchain_community.agent_toolkits import SQLDatabaseToolkit, SlackToolkit
from langchain_community.agent_toolkits import FileManagementToolkit
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_openai import ChatOpenAI

# Combine SQL + Slack + File tools
db = SQLDatabase.from_uri("sqlite:///analytics.db", include_tables=["metrics"])
llm = ChatOpenAI(model="gpt-4o", temperature=0)

sql_tools = SQLDatabaseToolkit(db=db, llm=llm).get_tools()
slack_tools = SlackToolkit().get_tools()
file_tools = FileManagementToolkit(
    root_dir="./reports",
    selected_tools=["write_file", "read_file"]
).get_tools()

all_tools = sql_tools + slack_tools + file_tools

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a business intelligence assistant with access to:
    - SQL database (read-only analytics data)
    - Slack (for notifications)
    - File system (for saving reports)
    
    Typical workflow: query data → save report → notify team on Slack."""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

agent = create_tool_calling_agent(llm, all_tools, prompt)
executor = AgentExecutor(agent=agent, tools=all_tools, verbose=True, max_iterations=15)

# Complex multi-step task
result = executor.invoke({
    "input": """
    1. Query the metrics table for this week's revenue by region
    2. Save the results as a CSV report file called 'weekly_revenue.csv'
    3. Send a summary to #analytics Slack channel
    """,
    "chat_history": []
})
print(result["output"])