langchain-agent-toolbox 0.1.0__tar.gz

langchain_agent_toolbox-0.1.0/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: langchain-agent-toolbox
+Version: 0.1.0
+Summary: LangChain integration for Agent Toolbox API — search, extract, screenshot, weather, finance, email validation, and translation tools for AI agents
+Author-email: Agent Toolbox <hello@agenttoolbox.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/Vincentwei1021/agent-toolbox
+Project-URL: Repository, https://github.com/Vincentwei1021/agent-toolbox/tree/master/integrations/langchain
+Project-URL: Documentation, https://github.com/Vincentwei1021/agent-toolbox#readme
+Project-URL: Issues, https://github.com/Vincentwei1021/agent-toolbox/issues
+Keywords: langchain,ai-agent,tools,mcp,search,web-scraping,screenshot,weather,finance,email-validation,translation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: langchain-core>=0.2.0
+Requires-Dist: httpx>=0.25.0
+
+# 🧰 langchain-agent-toolbox
+
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue)](https://pypi.org/project/langchain-agent-toolbox/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/Vincentwei1021/agent-toolbox/blob/master/LICENSE)
+
+**LangChain integration for [Agent Toolbox API](https://github.com/Vincentwei1021/agent-toolbox)** — 7 tools giving your LangChain agents real-world superpowers.
+
+| Tool | Endpoint | Description |
+|------|----------|-------------|
+| `AgentToolboxSearchTool` | `/v1/search` | Web search via DuckDuckGo |
+| `AgentToolboxExtractTool` | `/v1/extract` | Extract content from any URL |
+| `AgentToolboxScreenshotTool` | `/v1/screenshot` | Capture web page screenshots |
+| `AgentToolboxWeatherTool` | `/v1/weather` | Current weather & forecasts |
+| `AgentToolboxFinanceTool` | `/v1/finance` | Stock quotes & exchange rates |
+| `AgentToolboxEmailValidatorTool` | `/v1/validate-email` | Email validation (MX + SMTP + disposable) |
+| `AgentToolboxTranslateTool` | `/v1/translate` | Translation with auto-detect & glossary |
+
+## Installation
+
+```bash
+pip install langchain-agent-toolbox
+```
+
+## Quick Start
+
+### Get an API Key
+
+```bash
+curl -X POST https://api.sendtoclaw.com/v1/auth/register \
+  -H "Content-Type: application/json" \
+  -d '{"email": "you@example.com"}'
+```
+
+### Set Environment Variable
+
+```bash
+export AGENT_TOOLBOX_API_KEY="atb_your_key_here"
+```
+
+### Use with LangChain
+
+```python
+from langchain_agent_toolbox import AgentToolboxSearchTool, AgentToolboxWeatherTool
+
+# Initialize tools
+search = AgentToolboxSearchTool()
+weather = AgentToolboxWeatherTool()
+
+# Use directly
+results = search.invoke({"query": "latest AI news", "count": 3})
+print(results)
+
+forecast = weather.invoke({"location": "Tokyo"})
+print(forecast)
+```
+
+### Use with a LangChain Agent
+
+```python
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_agent_toolbox import (
+    AgentToolboxSearchTool,
+    AgentToolboxExtractTool,
+    AgentToolboxWeatherTool,
+    AgentToolboxTranslateTool,
+)
+
+# Initialize tools
+tools = [
+    AgentToolboxSearchTool(),
+    AgentToolboxExtractTool(),
+    AgentToolboxWeatherTool(),
+    AgentToolboxTranslateTool(),
+]
+
+# Create agent
+llm = ChatOpenAI(model="gpt-4o")
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant with access to web tools."),
+    ("human", "{input}"),
+    ("placeholder", "{agent_scratchpad}"),
+])
+
+agent = create_tool_calling_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+# Run
+result = executor.invoke({
+    "input": "What's the weather in Paris? Also search for top restaurants there."
+})
+print(result["output"])
+```
+
+### Translation with Glossary
+
+```python
+from langchain_agent_toolbox import AgentToolboxTranslateTool
+
+translate = AgentToolboxTranslateTool()
+
+# Simple translation
+result = translate.invoke({
+    "text": "Hello, how are you?",
+    "target": "zh",
+})
+print(result)  # 你好，你好吗？
+
+# With glossary (preserve technical terms)
+result = translate.invoke({
+    "text": "The API endpoint returns JSON data.",
+    "target": "zh",
+    "glossary": {"API": "API", "JSON": "JSON", "endpoint": "端点"},
+})
+print(result)  # API 端点 返回 JSON 数据。
+```
+
+### Email Validation
+
+```python
+from langchain_agent_toolbox import AgentToolboxEmailValidatorTool
+
+validator = AgentToolboxEmailValidatorTool()
+
+result = validator.invoke({"email": "test@gmail.com"})
+print(result)
+# {
+#   "email": "test@gmail.com",
+#   "valid_syntax": true,
+#   "mx_found": true,
+#   "is_disposable": false,
+#   "verdict": "deliverable",
+#   "score": 0.95
+# }
+```
+
+### Finance: Stocks & Exchange Rates
+
+```python
+from langchain_agent_toolbox import AgentToolboxFinanceTool
+
+finance = AgentToolboxFinanceTool()
+
+# Stock quote
+quote = finance.invoke({"symbol": "AAPL"})
+print(quote)
+
+# Currency exchange
+rate = finance.invoke({
+    "from_currency": "USD",
+    "to_currency": "EUR",
+    "amount": 100,
+    "type": "exchange",
+})
+print(rate)
+```
+
+## Configuration
+
+### API Key
+
+Set via environment variable (recommended):
+
+```bash
+export AGENT_TOOLBOX_API_KEY="atb_your_key_here"
+```
+
+Or pass directly:
+
+```python
+tool = AgentToolboxSearchTool(api_key="atb_your_key_here")
+```
+
+### Custom Base URL
+
+For self-hosted instances:
+
+```python
+tool = AgentToolboxSearchTool(
+    api_key="your-key",
+    base_url="http://localhost:3100",
+)
+```
+
+Or via environment variable:
+
+```bash
+export AGENT_TOOLBOX_BASE_URL="http://localhost:3100"
+```
+
+## Async Support
+
+All tools support async out of the box:
+
+```python
+import asyncio
+from langchain_agent_toolbox import AgentToolboxSearchTool
+
+async def main():
+    search = AgentToolboxSearchTool()
+    result = await search.ainvoke({"query": "async python", "count": 3})
+    print(result)
+
+asyncio.run(main())
+```
+
+## API Reference
+
+All tools accept these common parameters:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | `str` | `$AGENT_TOOLBOX_API_KEY` | API key for authentication |
+| `base_url` | `str` | `https://api.sendtoclaw.com` | API base URL |
+
+## Links
+
+- [Agent Toolbox API](https://github.com/Vincentwei1021/agent-toolbox) — main project
+- [OpenAPI Spec](https://api.sendtoclaw.com/v1/docs) — full API documentation
+- [LangChain](https://python.langchain.com/) — LangChain framework
+
+## License
+
+MIT

langchain_agent_toolbox-0.1.0/README.md

@@ -0,0 +1,225 @@
+# 🧰 langchain-agent-toolbox
+
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue)](https://pypi.org/project/langchain-agent-toolbox/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/Vincentwei1021/agent-toolbox/blob/master/LICENSE)
+
+**LangChain integration for [Agent Toolbox API](https://github.com/Vincentwei1021/agent-toolbox)** — 7 tools giving your LangChain agents real-world superpowers.
+
+| Tool | Endpoint | Description |
+|------|----------|-------------|
+| `AgentToolboxSearchTool` | `/v1/search` | Web search via DuckDuckGo |
+| `AgentToolboxExtractTool` | `/v1/extract` | Extract content from any URL |
+| `AgentToolboxScreenshotTool` | `/v1/screenshot` | Capture web page screenshots |
+| `AgentToolboxWeatherTool` | `/v1/weather` | Current weather & forecasts |
+| `AgentToolboxFinanceTool` | `/v1/finance` | Stock quotes & exchange rates |
+| `AgentToolboxEmailValidatorTool` | `/v1/validate-email` | Email validation (MX + SMTP + disposable) |
+| `AgentToolboxTranslateTool` | `/v1/translate` | Translation with auto-detect & glossary |
+
+## Installation
+
+```bash
+pip install langchain-agent-toolbox
+```
+
+## Quick Start
+
+### Get an API Key
+
+```bash
+curl -X POST https://api.sendtoclaw.com/v1/auth/register \
+  -H "Content-Type: application/json" \
+  -d '{"email": "you@example.com"}'
+```
+
+### Set Environment Variable
+
+```bash
+export AGENT_TOOLBOX_API_KEY="atb_your_key_here"
+```
+
+### Use with LangChain
+
+```python
+from langchain_agent_toolbox import AgentToolboxSearchTool, AgentToolboxWeatherTool
+
+# Initialize tools
+search = AgentToolboxSearchTool()
+weather = AgentToolboxWeatherTool()
+
+# Use directly
+results = search.invoke({"query": "latest AI news", "count": 3})
+print(results)
+
+forecast = weather.invoke({"location": "Tokyo"})
+print(forecast)
+```
+
+### Use with a LangChain Agent
+
+```python
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_agent_toolbox import (
+    AgentToolboxSearchTool,
+    AgentToolboxExtractTool,
+    AgentToolboxWeatherTool,
+    AgentToolboxTranslateTool,
+)
+
+# Initialize tools
+tools = [
+    AgentToolboxSearchTool(),
+    AgentToolboxExtractTool(),
+    AgentToolboxWeatherTool(),
+    AgentToolboxTranslateTool(),
+]
+
+# Create agent
+llm = ChatOpenAI(model="gpt-4o")
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant with access to web tools."),
+    ("human", "{input}"),
+    ("placeholder", "{agent_scratchpad}"),
+])
+
+agent = create_tool_calling_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+# Run
+result = executor.invoke({
+    "input": "What's the weather in Paris? Also search for top restaurants there."
+})
+print(result["output"])
+```
+
+### Translation with Glossary
+
+```python
+from langchain_agent_toolbox import AgentToolboxTranslateTool
+
+translate = AgentToolboxTranslateTool()
+
+# Simple translation
+result = translate.invoke({
+    "text": "Hello, how are you?",
+    "target": "zh",
+})
+print(result)  # 你好，你好吗？
+
+# With glossary (preserve technical terms)
+result = translate.invoke({
+    "text": "The API endpoint returns JSON data.",
+    "target": "zh",
+    "glossary": {"API": "API", "JSON": "JSON", "endpoint": "端点"},
+})
+print(result)  # API 端点 返回 JSON 数据。
+```
+
+### Email Validation
+
+```python
+from langchain_agent_toolbox import AgentToolboxEmailValidatorTool
+
+validator = AgentToolboxEmailValidatorTool()
+
+result = validator.invoke({"email": "test@gmail.com"})
+print(result)
+# {
+#   "email": "test@gmail.com",
+#   "valid_syntax": true,
+#   "mx_found": true,
+#   "is_disposable": false,
+#   "verdict": "deliverable",
+#   "score": 0.95
+# }
+```
+
+### Finance: Stocks & Exchange Rates
+
+```python
+from langchain_agent_toolbox import AgentToolboxFinanceTool
+
+finance = AgentToolboxFinanceTool()
+
+# Stock quote
+quote = finance.invoke({"symbol": "AAPL"})
+print(quote)
+
+# Currency exchange
+rate = finance.invoke({
+    "from_currency": "USD",
+    "to_currency": "EUR",
+    "amount": 100,
+    "type": "exchange",
+})
+print(rate)
+```
+
+## Configuration
+
+### API Key
+
+Set via environment variable (recommended):
+
+```bash
+export AGENT_TOOLBOX_API_KEY="atb_your_key_here"
+```
+
+Or pass directly:
+
+```python
+tool = AgentToolboxSearchTool(api_key="atb_your_key_here")
+```
+
+### Custom Base URL
+
+For self-hosted instances:
+
+```python
+tool = AgentToolboxSearchTool(
+    api_key="your-key",
+    base_url="http://localhost:3100",
+)
+```
+
+Or via environment variable:
+
+```bash
+export AGENT_TOOLBOX_BASE_URL="http://localhost:3100"
+```
+
+## Async Support
+
+All tools support async out of the box:
+
+```python
+import asyncio
+from langchain_agent_toolbox import AgentToolboxSearchTool
+
+async def main():
+    search = AgentToolboxSearchTool()
+    result = await search.ainvoke({"query": "async python", "count": 3})
+    print(result)
+
+asyncio.run(main())
+```
+
+## API Reference
+
+All tools accept these common parameters:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | `str` | `$AGENT_TOOLBOX_API_KEY` | API key for authentication |
+| `base_url` | `str` | `https://api.sendtoclaw.com` | API base URL |
+
+## Links
+
+- [Agent Toolbox API](https://github.com/Vincentwei1021/agent-toolbox) — main project
+- [OpenAPI Spec](https://api.sendtoclaw.com/v1/docs) — full API documentation
+- [LangChain](https://python.langchain.com/) — LangChain framework
+
+## License
+
+MIT

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox/__init__.py

@@ -0,0 +1,23 @@
+"""LangChain integration for Agent Toolbox API."""
+
+from langchain_agent_toolbox.tools import (
+    AgentToolboxSearchTool,
+    AgentToolboxExtractTool,
+    AgentToolboxScreenshotTool,
+    AgentToolboxWeatherTool,
+    AgentToolboxFinanceTool,
+    AgentToolboxEmailValidatorTool,
+    AgentToolboxTranslateTool,
+)
+
+__all__ = [
+    "AgentToolboxSearchTool",
+    "AgentToolboxExtractTool",
+    "AgentToolboxScreenshotTool",
+    "AgentToolboxWeatherTool",
+    "AgentToolboxFinanceTool",
+    "AgentToolboxEmailValidatorTool",
+    "AgentToolboxTranslateTool",
+]
+
+__version__ = "0.1.0"

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox/client.py

@@ -0,0 +1,48 @@
+"""HTTP client for Agent Toolbox API."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import httpx
+
+
+DEFAULT_BASE_URL = "https://api.sendtoclaw.com"
+DEFAULT_TIMEOUT = 30.0
+
+
+class AgentToolboxClient:
+    """Thin HTTP client for the Agent Toolbox REST API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _headers(self) -> Dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "x-api-key": self.api_key,
+            "Content-Type": "application/json",
+        }
+
+    def post(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Synchronous POST request."""
+        url = f"{self.base_url}{endpoint}"
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.post(url, json=payload, headers=self._headers())
+            resp.raise_for_status()
+            return resp.json()
+
+    async def apost(self, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Async POST request."""
+        url = f"{self.base_url}{endpoint}"
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            resp = await client.post(url, json=payload, headers=self._headers())
+            resp.raise_for_status()
+            return resp.json()

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox/tools.py

@@ -0,0 +1,364 @@
+"""LangChain tools for Agent Toolbox API."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, List, Optional, Type
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from langchain_agent_toolbox.client import AgentToolboxClient, DEFAULT_BASE_URL
+
+
+def _get_client(
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+) -> AgentToolboxClient:
+    key = api_key or os.environ.get("AGENT_TOOLBOX_API_KEY", "")
+    if not key:
+        raise ValueError(
+            "Agent Toolbox API key is required. "
+            "Pass api_key= or set AGENT_TOOLBOX_API_KEY env var."
+        )
+    url = base_url or os.environ.get("AGENT_TOOLBOX_BASE_URL", DEFAULT_BASE_URL)
+    return AgentToolboxClient(api_key=key, base_url=url)
+
+
+# ---------------------------------------------------------------------------
+# Search
+# ---------------------------------------------------------------------------
+
+class SearchInput(BaseModel):
+    query: str = Field(description="Search query string")
+    count: int = Field(default=5, description="Number of results (1-10)")
+
+
+class AgentToolboxSearchTool(BaseTool):
+    """Search the web using Agent Toolbox API (DuckDuckGo backend)."""
+
+    name: str = "agent_toolbox_search"
+    description: str = (
+        "Search the web and get titles, URLs, and snippets. "
+        "Useful for finding up-to-date information on any topic."
+    )
+    args_schema: Type[BaseModel] = SearchInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        query: str,
+        count: int = 5,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = client.post("/v1/search", {"query": query, "count": count})
+        return json.dumps(result.get("data", []), indent=2)
+
+    async def _arun(
+        self,
+        query: str,
+        count: int = 5,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = await client.apost("/v1/search", {"query": query, "count": count})
+        return json.dumps(result.get("data", []), indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Extract
+# ---------------------------------------------------------------------------
+
+class ExtractInput(BaseModel):
+    url: str = Field(description="URL to extract content from")
+    format: str = Field(default="markdown", description="Output format: markdown, text, or json")
+
+
+class AgentToolboxExtractTool(BaseTool):
+    """Extract readable content from a web page."""
+
+    name: str = "agent_toolbox_extract"
+    description: str = (
+        "Extract the main readable content from a web page URL. "
+        "Returns clean text/markdown, removing ads and navigation."
+    )
+    args_schema: Type[BaseModel] = ExtractInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        url: str,
+        format: str = "markdown",
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = client.post("/v1/extract", {"url": url, "format": format})
+        data = result.get("data", {})
+        return data.get("content", json.dumps(data, indent=2))
+
+    async def _arun(
+        self,
+        url: str,
+        format: str = "markdown",
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = await client.apost("/v1/extract", {"url": url, "format": format})
+        data = result.get("data", {})
+        return data.get("content", json.dumps(data, indent=2))
+
+
+# ---------------------------------------------------------------------------
+# Screenshot
+# ---------------------------------------------------------------------------
+
+class ScreenshotInput(BaseModel):
+    url: str = Field(description="URL to screenshot")
+    width: int = Field(default=1280, description="Viewport width in pixels")
+    height: int = Field(default=720, description="Viewport height in pixels")
+
+
+class AgentToolboxScreenshotTool(BaseTool):
+    """Take a screenshot of a web page."""
+
+    name: str = "agent_toolbox_screenshot"
+    description: str = (
+        "Capture a screenshot of a web page. "
+        "Returns base64-encoded PNG image data."
+    )
+    args_schema: Type[BaseModel] = ScreenshotInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        url: str,
+        width: int = 1280,
+        height: int = 720,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = client.post("/v1/screenshot", {"url": url, "width": width, "height": height})
+        return json.dumps(result.get("data", {}), indent=2)
+
+    async def _arun(
+        self,
+        url: str,
+        width: int = 1280,
+        height: int = 720,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = await client.apost("/v1/screenshot", {"url": url, "width": width, "height": height})
+        return json.dumps(result.get("data", {}), indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Weather
+# ---------------------------------------------------------------------------
+
+class WeatherInput(BaseModel):
+    location: str = Field(description="City name or location")
+
+
+class AgentToolboxWeatherTool(BaseTool):
+    """Get current weather and forecast for a location."""
+
+    name: str = "agent_toolbox_weather"
+    description: str = (
+        "Get current weather conditions and forecast for any location. "
+        "Returns temperature, humidity, wind, and multi-day forecast."
+    )
+    args_schema: Type[BaseModel] = WeatherInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        location: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = client.post("/v1/weather", {"location": location})
+        return json.dumps(result.get("data", {}), indent=2)
+
+    async def _arun(
+        self,
+        location: str,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = await client.apost("/v1/weather", {"location": location})
+        return json.dumps(result.get("data", {}), indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Finance
+# ---------------------------------------------------------------------------
+
+class FinanceInput(BaseModel):
+    symbol: Optional[str] = Field(default=None, description="Stock ticker symbol (e.g. AAPL)")
+    type: Optional[str] = Field(default="quote", description="Request type: quote or exchange")
+    from_currency: Optional[str] = Field(default=None, description="Source currency code (for exchange)", alias="from")
+    to_currency: Optional[str] = Field(default=None, description="Target currency code (for exchange)", alias="to")
+    amount: Optional[float] = Field(default=None, description="Amount to convert (for exchange)")
+
+    class Config:
+        populate_by_name = True
+
+
+class AgentToolboxFinanceTool(BaseTool):
+    """Get stock quotes or currency exchange rates."""
+
+    name: str = "agent_toolbox_finance"
+    description: str = (
+        "Get real-time stock quotes or currency exchange rates. "
+        "For stocks: provide symbol (e.g. 'AAPL'). "
+        "For exchange rates: provide from, to, and amount."
+    )
+    args_schema: Type[BaseModel] = FinanceInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        symbol: Optional[str] = None,
+        type: Optional[str] = "quote",
+        from_currency: Optional[str] = None,
+        to_currency: Optional[str] = None,
+        amount: Optional[float] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        payload: Dict[str, Any] = {}
+        if symbol:
+            payload = {"symbol": symbol, "type": type or "quote"}
+        elif from_currency and to_currency:
+            payload = {"from": from_currency, "to": to_currency, "amount": amount or 1}
+        result = client.post("/v1/finance", payload)
+        return json.dumps(result.get("data", {}), indent=2)
+
+    async def _arun(
+        self,
+        symbol: Optional[str] = None,
+        type: Optional[str] = "quote",
+        from_currency: Optional[str] = None,
+        to_currency: Optional[str] = None,
+        amount: Optional[float] = None,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        payload: Dict[str, Any] = {}
+        if symbol:
+            payload = {"symbol": symbol, "type": type or "quote"}
+        elif from_currency and to_currency:
+            payload = {"from": from_currency, "to": to_currency, "amount": amount or 1}
+        result = await client.apost("/v1/finance", payload)
+        return json.dumps(result.get("data", {}), indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Email Validator
+# ---------------------------------------------------------------------------
+
+class EmailValidatorInput(BaseModel):
+    email: str = Field(description="Email address to validate")
+
+
+class AgentToolboxEmailValidatorTool(BaseTool):
+    """Validate an email address (syntax, MX, SMTP, disposable check)."""
+
+    name: str = "agent_toolbox_email_validator"
+    description: str = (
+        "Validate an email address by checking syntax, MX records, "
+        "SMTP reachability, and disposable domain detection. "
+        "Returns a verdict: deliverable, risky, undeliverable, or invalid."
+    )
+    args_schema: Type[BaseModel] = EmailValidatorInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        email: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = client.post("/v1/validate-email", {"email": email})
+        return json.dumps(result.get("data", {}), indent=2)
+
+    async def _arun(
+        self,
+        email: str,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        result = await client.apost("/v1/validate-email", {"email": email})
+        return json.dumps(result.get("data", {}), indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Translate
+# ---------------------------------------------------------------------------
+
+class TranslateInput(BaseModel):
+    text: str = Field(description="Text to translate")
+    target: str = Field(description="Target language code (e.g. zh, ja, es, fr)")
+    source: str = Field(default="auto", description="Source language code or 'auto'")
+    glossary: Optional[Dict[str, str]] = Field(default=None, description="Optional glossary: {term: translation}")
+
+
+class AgentToolboxTranslateTool(BaseTool):
+    """Translate text between 100+ languages."""
+
+    name: str = "agent_toolbox_translate"
+    description: str = (
+        "Translate text between languages with automatic language detection. "
+        "Supports glossary for preserving specific terms. "
+        "Provide target language code (e.g. 'zh' for Chinese, 'ja' for Japanese)."
+    )
+    args_schema: Type[BaseModel] = TranslateInput
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+
+    def _run(
+        self,
+        text: str,
+        target: str,
+        source: str = "auto",
+        glossary: Optional[Dict[str, str]] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        payload: Dict[str, Any] = {"text": text, "target": target, "source": source}
+        if glossary:
+            payload["glossary"] = glossary
+        result = client.post("/v1/translate", payload)
+        data = result.get("data", {})
+        return data.get("translation", json.dumps(data, indent=2))
+
+    async def _arun(
+        self,
+        text: str,
+        target: str,
+        source: str = "auto",
+        glossary: Optional[Dict[str, str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> str:
+        client = _get_client(self.api_key, self.base_url)
+        payload: Dict[str, Any] = {"text": text, "target": target, "source": source}
+        if glossary:
+            payload["glossary"] = glossary
+        result = await client.apost("/v1/translate", payload)
+        data = result.get("data", {})
+        return data.get("translation", json.dumps(data, indent=2))

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox.egg-info/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: langchain-agent-toolbox
+Version: 0.1.0
+Summary: LangChain integration for Agent Toolbox API — search, extract, screenshot, weather, finance, email validation, and translation tools for AI agents
+Author-email: Agent Toolbox <hello@agenttoolbox.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/Vincentwei1021/agent-toolbox
+Project-URL: Repository, https://github.com/Vincentwei1021/agent-toolbox/tree/master/integrations/langchain
+Project-URL: Documentation, https://github.com/Vincentwei1021/agent-toolbox#readme
+Project-URL: Issues, https://github.com/Vincentwei1021/agent-toolbox/issues
+Keywords: langchain,ai-agent,tools,mcp,search,web-scraping,screenshot,weather,finance,email-validation,translation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: langchain-core>=0.2.0
+Requires-Dist: httpx>=0.25.0
+
+# 🧰 langchain-agent-toolbox
+
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue)](https://pypi.org/project/langchain-agent-toolbox/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/Vincentwei1021/agent-toolbox/blob/master/LICENSE)
+
+**LangChain integration for [Agent Toolbox API](https://github.com/Vincentwei1021/agent-toolbox)** — 7 tools giving your LangChain agents real-world superpowers.
+
+| Tool | Endpoint | Description |
+|------|----------|-------------|
+| `AgentToolboxSearchTool` | `/v1/search` | Web search via DuckDuckGo |
+| `AgentToolboxExtractTool` | `/v1/extract` | Extract content from any URL |
+| `AgentToolboxScreenshotTool` | `/v1/screenshot` | Capture web page screenshots |
+| `AgentToolboxWeatherTool` | `/v1/weather` | Current weather & forecasts |
+| `AgentToolboxFinanceTool` | `/v1/finance` | Stock quotes & exchange rates |
+| `AgentToolboxEmailValidatorTool` | `/v1/validate-email` | Email validation (MX + SMTP + disposable) |
+| `AgentToolboxTranslateTool` | `/v1/translate` | Translation with auto-detect & glossary |
+
+## Installation
+
+```bash
+pip install langchain-agent-toolbox
+```
+
+## Quick Start
+
+### Get an API Key
+
+```bash
+curl -X POST https://api.sendtoclaw.com/v1/auth/register \
+  -H "Content-Type: application/json" \
+  -d '{"email": "you@example.com"}'
+```
+
+### Set Environment Variable
+
+```bash
+export AGENT_TOOLBOX_API_KEY="atb_your_key_here"
+```
+
+### Use with LangChain
+
+```python
+from langchain_agent_toolbox import AgentToolboxSearchTool, AgentToolboxWeatherTool
+
+# Initialize tools
+search = AgentToolboxSearchTool()
+weather = AgentToolboxWeatherTool()
+
+# Use directly
+results = search.invoke({"query": "latest AI news", "count": 3})
+print(results)
+
+forecast = weather.invoke({"location": "Tokyo"})
+print(forecast)
+```
+
+### Use with a LangChain Agent
+
+```python
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_agent_toolbox import (
+    AgentToolboxSearchTool,
+    AgentToolboxExtractTool,
+    AgentToolboxWeatherTool,
+    AgentToolboxTranslateTool,
+)
+
+# Initialize tools
+tools = [
+    AgentToolboxSearchTool(),
+    AgentToolboxExtractTool(),
+    AgentToolboxWeatherTool(),
+    AgentToolboxTranslateTool(),
+]
+
+# Create agent
+llm = ChatOpenAI(model="gpt-4o")
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant with access to web tools."),
+    ("human", "{input}"),
+    ("placeholder", "{agent_scratchpad}"),
+])
+
+agent = create_tool_calling_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+# Run
+result = executor.invoke({
+    "input": "What's the weather in Paris? Also search for top restaurants there."
+})
+print(result["output"])
+```
+
+### Translation with Glossary
+
+```python
+from langchain_agent_toolbox import AgentToolboxTranslateTool
+
+translate = AgentToolboxTranslateTool()
+
+# Simple translation
+result = translate.invoke({
+    "text": "Hello, how are you?",
+    "target": "zh",
+})
+print(result)  # 你好，你好吗？
+
+# With glossary (preserve technical terms)
+result = translate.invoke({
+    "text": "The API endpoint returns JSON data.",
+    "target": "zh",
+    "glossary": {"API": "API", "JSON": "JSON", "endpoint": "端点"},
+})
+print(result)  # API 端点 返回 JSON 数据。
+```
+
+### Email Validation
+
+```python
+from langchain_agent_toolbox import AgentToolboxEmailValidatorTool
+
+validator = AgentToolboxEmailValidatorTool()
+
+result = validator.invoke({"email": "test@gmail.com"})
+print(result)
+# {
+#   "email": "test@gmail.com",
+#   "valid_syntax": true,
+#   "mx_found": true,
+#   "is_disposable": false,
+#   "verdict": "deliverable",
+#   "score": 0.95
+# }
+```
+
+### Finance: Stocks & Exchange Rates
+
+```python
+from langchain_agent_toolbox import AgentToolboxFinanceTool
+
+finance = AgentToolboxFinanceTool()
+
+# Stock quote
+quote = finance.invoke({"symbol": "AAPL"})
+print(quote)
+
+# Currency exchange
+rate = finance.invoke({
+    "from_currency": "USD",
+    "to_currency": "EUR",
+    "amount": 100,
+    "type": "exchange",
+})
+print(rate)
+```
+
+## Configuration
+
+### API Key
+
+Set via environment variable (recommended):
+
+```bash
+export AGENT_TOOLBOX_API_KEY="atb_your_key_here"
+```
+
+Or pass directly:
+
+```python
+tool = AgentToolboxSearchTool(api_key="atb_your_key_here")
+```
+
+### Custom Base URL
+
+For self-hosted instances:
+
+```python
+tool = AgentToolboxSearchTool(
+    api_key="your-key",
+    base_url="http://localhost:3100",
+)
+```
+
+Or via environment variable:
+
+```bash
+export AGENT_TOOLBOX_BASE_URL="http://localhost:3100"
+```
+
+## Async Support
+
+All tools support async out of the box:
+
+```python
+import asyncio
+from langchain_agent_toolbox import AgentToolboxSearchTool
+
+async def main():
+    search = AgentToolboxSearchTool()
+    result = await search.ainvoke({"query": "async python", "count": 3})
+    print(result)
+
+asyncio.run(main())
+```
+
+## API Reference
+
+All tools accept these common parameters:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_key` | `str` | `$AGENT_TOOLBOX_API_KEY` | API key for authentication |
+| `base_url` | `str` | `https://api.sendtoclaw.com` | API base URL |
+
+## Links
+
+- [Agent Toolbox API](https://github.com/Vincentwei1021/agent-toolbox) — main project
+- [OpenAPI Spec](https://api.sendtoclaw.com/v1/docs) — full API documentation
+- [LangChain](https://python.langchain.com/) — LangChain framework
+
+## License
+
+MIT

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+langchain_agent_toolbox/__init__.py
+langchain_agent_toolbox/client.py
+langchain_agent_toolbox/py.typed
+langchain_agent_toolbox/tools.py
+langchain_agent_toolbox.egg-info/PKG-INFO
+langchain_agent_toolbox.egg-info/SOURCES.txt
+langchain_agent_toolbox.egg-info/dependency_links.txt
+langchain_agent_toolbox.egg-info/requires.txt
+langchain_agent_toolbox.egg-info/top_level.txt
+tests/test_tools.py

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox.egg-info/requires.txt

@@ -0,0 +1,2 @@
+langchain-core>=0.2.0
+httpx>=0.25.0

langchain_agent_toolbox-0.1.0/langchain_agent_toolbox.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_agent_toolbox

langchain_agent_toolbox-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-agent-toolbox"
+version = "0.1.0"
+description = "LangChain integration for Agent Toolbox API — search, extract, screenshot, weather, finance, email validation, and translation tools for AI agents"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Agent Toolbox", email = "hello@agenttoolbox.dev"},
+]
+keywords = ["langchain", "ai-agent", "tools", "mcp", "search", "web-scraping", "screenshot", "weather", "finance", "email-validation", "translation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "langchain-core>=0.2.0",
+    "httpx>=0.25.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Vincentwei1021/agent-toolbox"
+Repository = "https://github.com/Vincentwei1021/agent-toolbox/tree/master/integrations/langchain"
+Documentation = "https://github.com/Vincentwei1021/agent-toolbox#readme"
+Issues = "https://github.com/Vincentwei1021/agent-toolbox/issues"
+
+[tool.setuptools.packages.find]
+include = ["langchain_agent_toolbox*"]

langchain_agent_toolbox-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langchain_agent_toolbox-0.1.0/tests/test_tools.py

@@ -0,0 +1,42 @@
+"""Basic import and instantiation tests for langchain-agent-toolbox."""
+
+import os
+import pytest
+
+
+def test_imports():
+    from langchain_agent_toolbox import (
+        AgentToolboxSearchTool,
+        AgentToolboxExtractTool,
+        AgentToolboxScreenshotTool,
+        AgentToolboxWeatherTool,
+        AgentToolboxFinanceTool,
+        AgentToolboxEmailValidatorTool,
+        AgentToolboxTranslateTool,
+    )
+    assert AgentToolboxSearchTool is not None
+    assert AgentToolboxTranslateTool is not None
+
+
+def test_tool_instantiation():
+    from langchain_agent_toolbox import AgentToolboxSearchTool
+    tool = AgentToolboxSearchTool(api_key="test-key")
+    assert tool.name == "agent_toolbox_search"
+    assert "search" in tool.description.lower()
+
+
+def test_tool_schema():
+    from langchain_agent_toolbox import AgentToolboxTranslateTool
+    tool = AgentToolboxTranslateTool(api_key="test-key")
+    schema = tool.args_schema.model_json_schema()
+    assert "text" in schema["properties"]
+    assert "target" in schema["properties"]
+
+
+def test_missing_api_key():
+    from langchain_agent_toolbox import AgentToolboxSearchTool
+    # Clear env var if set
+    os.environ.pop("AGENT_TOOLBOX_API_KEY", None)
+    tool = AgentToolboxSearchTool()
+    with pytest.raises(ValueError, match="API key is required"):
+        tool._run(query="test")