langchain-proxyclaw 0.1.0__tar.gz

langchain_proxyclaw-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IPLoop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_proxyclaw-0.1.0/Makefile

@@ -0,0 +1,44 @@
+.PHONY: help install install-dev test lint format clean build publish
+
+help:
+	@echo "Available commands:"
+	@echo "  install      - Install package"
+	@echo "  install-dev  - Install with dev dependencies"
+	@echo "  test         - Run tests"
+	@echo "  lint         - Run linters"
+	@echo "  format       - Format code with black"
+	@echo "  clean        - Clean build artifacts"
+	@echo "  build        - Build package"
+	@echo "  publish      - Publish to PyPI"
+
+install:
+	pip install -e .
+
+install-dev:
+	pip install -e ".[dev]"
+
+test:
+	pytest tests/ -v --cov=langchain_proxyclaw --cov-report=term-missing
+
+lint:
+	mypy langchain_proxyclaw/
+	flake8 langchain_proxyclaw/ tests/
+
+format:
+	black langchain_proxyclaw/ tests/
+
+clean:
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info/
+	find . -type d -name __pycache__ -exec rm -rf {} +
+	find . -type f -name "*.pyc" -delete
+
+build: clean
+	python -m build
+
+publish: build
+	python -m twine upload dist/*
+
+check: lint test
+	@echo "All checks passed!"

langchain_proxyclaw-0.1.0/PKG-INFO

@@ -0,0 +1,291 @@
+Metadata-Version: 2.4
+Name: langchain-proxyclaw
+Version: 0.1.0
+Summary: LangChain integration for ProxyClaw - residential proxy network
+Project-URL: Homepage, https://proxyclaw.ai
+Project-URL: Documentation, https://docs.proxyclaw.ai
+Project-URL: Repository, https://github.com/iploop/langchain-proxyclaw
+Project-URL: Bug Tracker, https://github.com/iploop/langchain-proxyclaw/issues
+Author-email: IPLoop Team <support@iploop.io>
+License: MIT
+License-File: LICENSE
+Keywords: iploop,langchain,proxy,proxyclaw,residential,scraping
+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 :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: iploop-sdk>=1.8.0
+Requires-Dist: langchain-core>=0.1.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: beautifulsoup4>=4.12.0; extra == 'dev'
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# LangChain ProxyClaw Integration
+
+[![PyPI version](https://badge.fury.io/py/langchain-proxyclaw.svg)](https://badge.fury.io/py/langchain-proxyclaw)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official LangChain integration for [ProxyClaw](https://proxyclaw.ai) - a residential proxy network with 10M+ IPs across 111+ countries.
+
+## Overview
+
+This package provides LangChain Tools for routing HTTP requests through ProxyClaw's residential proxy network, enabling AI agents to scrape websites with:
+
+- 🌍 **Global IP coverage** - 111+ countries
+- 🔄 **Automatic rotation** - Fresh IPs per request or sticky sessions
+- 🛡️ **Anti-detection** - Built-in fingerprint spoofing
+- ⚡ **High success rate** - Residential IPs bypass most blocks
+
+## Installation
+
+```bash
+pip install langchain-proxyclaw
+```
+
+For development:
+
+```bash
+pip install langchain-proxyclaw[dev]
+```
+
+## Quick Start
+
+```python
+from langchain_proxyclaw import ProxyClawTool
+from langchain.agents import AgentType, initialize_agent
+from langchain_openai import ChatOpenAI
+
+# Initialize the tool
+tool = ProxyClawTool(api_key="your_api_key")
+
+# Use with an agent
+llm = ChatOpenAI(temperature=0)
+agent = initialize_agent(
+    [tool],
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True
+)
+
+# Ask the agent to scrape a website
+agent.run("Get the content from https://example.com using a US proxy")
+```
+
+## Tools
+
+### 1. ProxyClawTool
+
+Basic HTTP requests through ProxyClaw proxies.
+
+```python
+from langchain_proxyclaw import ProxyClawTool
+
+tool = ProxyClawTool(api_key="your_api_key")
+
+# Simple GET request
+result = tool.invoke({
+    "url": "https://example.com",
+    "country": "US"
+})
+
+# POST request with data
+result = tool.invoke({
+    "url": "https://api.example.com/data",
+    "method": "POST",
+    "data": {"key": "value"},
+    "headers": {"Authorization": "Bearer token"},
+    "country": "GB"
+})
+```
+
+**Parameters:**
+- `url` (str, required): Target URL
+- `method` (str): HTTP method (GET, POST, PUT, DELETE) - default: GET
+- `headers` (dict): Optional HTTP headers
+- `data` (str/dict): Request body data
+- `country` (str): Country code for proxy location (e.g., "US", "GB", "DE")
+- `session_id` (str): Session ID for sticky sessions
+
+### 2. ProxyClawSessionTool
+
+Sticky proxy sessions for multi-step workflows.
+
+```python
+from langchain_proxyclaw import ProxyClawSessionTool
+
+tool = ProxyClawSessionTool(api_key="your_api_key")
+
+# Scrape multiple pages with the same IP
+result = tool.invoke({
+    "urls": [
+        "https://site.com/login",
+        "https://site.com/dashboard",
+        "https://site.com/profile"
+    ],
+    "country": "US"
+})
+```
+
+**Parameters:**
+- `urls` (list[str], required): List of URLs to fetch
+- `country` (str): Country code
+- `session_lifetime` (int): Session duration in minutes - default: 30
+
+### 3. ProxyClawScraperTool
+
+Advanced scraper with retries and auto-rotation.
+
+```python
+from langchain_proxyclaw import ProxyClawScraperTool
+
+tool = ProxyClawScraperTool(api_key="your_api_key")
+
+# Scrape with retries and link extraction
+result = tool.invoke({
+    "url": "https://example.com/products",
+    "country": "US",
+    "retries": 3,
+    "timeout": 30,
+    "extract_links": True
+})
+```
+
+**Parameters:**
+- `url` (str, required): Target URL
+- `country` (str): Country code
+- `retries` (int): Number of retry attempts - default: 3
+- `timeout` (int): Request timeout in seconds - default: 30
+- `extract_links` (bool): Extract all links from the page - default: False
+
+## Authentication
+
+Get your API key from [ProxyClaw Dashboard](https://platform.proxyclaw.ai):
+
+```python
+api_key = "pk_live_xxxxxxxxxxxxxxxx"
+```
+
+## Country Codes
+
+Common country codes:
+- `US` - United States
+- `GB` - United Kingdom
+- `DE` - Germany
+- `FR` - France
+- `JP` - Japan
+- `IN` - India
+- `BR` - Brazil
+
+Full list: 111+ countries supported. Use ISO 3166-1 alpha-2 codes.
+
+## Use Cases
+
+### Web Scraping for AI Agents
+
+```python
+from langchain_proxyclaw import ProxyClawScraperTool
+from langchain.agents import AgentType, initialize_agent
+
+scraper = ProxyClawScraperTool(api_key="your_api_key")
+
+agent = initialize_agent(
+    [scraper],
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
+)
+
+# Agent can now scrape without being blocked
+agent.run("Find pricing information from https://competitor.com/pricing")
+```
+
+### E-commerce Monitoring
+
+```python
+session_tool = ProxyClawSessionTool(api_key="your_api_key")
+
+# Same IP for login + price check
+result = session_tool.invoke({
+    "urls": [
+        "https://shop.com/login",
+        "https://shop.com/product/123"
+    ],
+    "country": "US"
+})
+```
+
+### Market Research
+
+```python
+from langchain_proxyclaw import ProxyClawTool
+
+tool = ProxyClawTool(api_key="your_api_key")
+
+# Check how a site appears from different countries
+for country in ["US", "GB", "DE", "JP"]:
+    result = tool.invoke({
+        "url": "https://global-site.com",
+        "country": country
+    })
+    print(f"{country}: {result}")
+```
+
+## LangChain Integration Tests
+
+To run LangChain's standard integration tests:
+
+```bash
+pip install langchain-proxyclaw[dev]
+pytest tests/ -v
+```
+
+## Documentation
+
+Full documentation: [docs.proxyclaw.ai](https://docs.proxyclaw.ai)
+
+LangChain docs: [python.langchain.com](https://python.langchain.com)
+
+## API Reference
+
+See [ProxyClaw API Docs](https://docs.proxyclaw.ai/api) for details on:
+- Authentication formats
+- Country targeting
+- Session management
+- Bandwidth tracking
+
+## Pricing
+
+ProxyClaw uses pay-as-you-go pricing:
+- $0.35/GB under 10TB
+- $0.25/GB over 10TB
+
+No minimums, no commitments. [Sign up](https://proxyclaw.ai)
+
+## Support
+
+- 📧 Email: support@iploop.io
+- 💬 Discord: [discord.gg/clawd](https://discord.gg/clawd)
+- 📖 Docs: [docs.proxyclaw.ai](https://docs.proxyclaw.ai)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+## Contributing
+
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+---
+
+Built with ❤️ by the [IPLoop](https://iploop.io) team.

langchain_proxyclaw-0.1.0/README.md

@@ -0,0 +1,257 @@
+# LangChain ProxyClaw Integration
+
+[![PyPI version](https://badge.fury.io/py/langchain-proxyclaw.svg)](https://badge.fury.io/py/langchain-proxyclaw)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official LangChain integration for [ProxyClaw](https://proxyclaw.ai) - a residential proxy network with 10M+ IPs across 111+ countries.
+
+## Overview
+
+This package provides LangChain Tools for routing HTTP requests through ProxyClaw's residential proxy network, enabling AI agents to scrape websites with:
+
+- 🌍 **Global IP coverage** - 111+ countries
+- 🔄 **Automatic rotation** - Fresh IPs per request or sticky sessions
+- 🛡️ **Anti-detection** - Built-in fingerprint spoofing
+- ⚡ **High success rate** - Residential IPs bypass most blocks
+
+## Installation
+
+```bash
+pip install langchain-proxyclaw
+```
+
+For development:
+
+```bash
+pip install langchain-proxyclaw[dev]
+```
+
+## Quick Start
+
+```python
+from langchain_proxyclaw import ProxyClawTool
+from langchain.agents import AgentType, initialize_agent
+from langchain_openai import ChatOpenAI
+
+# Initialize the tool
+tool = ProxyClawTool(api_key="your_api_key")
+
+# Use with an agent
+llm = ChatOpenAI(temperature=0)
+agent = initialize_agent(
+    [tool],
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True
+)
+
+# Ask the agent to scrape a website
+agent.run("Get the content from https://example.com using a US proxy")
+```
+
+## Tools
+
+### 1. ProxyClawTool
+
+Basic HTTP requests through ProxyClaw proxies.
+
+```python
+from langchain_proxyclaw import ProxyClawTool
+
+tool = ProxyClawTool(api_key="your_api_key")
+
+# Simple GET request
+result = tool.invoke({
+    "url": "https://example.com",
+    "country": "US"
+})
+
+# POST request with data
+result = tool.invoke({
+    "url": "https://api.example.com/data",
+    "method": "POST",
+    "data": {"key": "value"},
+    "headers": {"Authorization": "Bearer token"},
+    "country": "GB"
+})
+```
+
+**Parameters:**
+- `url` (str, required): Target URL
+- `method` (str): HTTP method (GET, POST, PUT, DELETE) - default: GET
+- `headers` (dict): Optional HTTP headers
+- `data` (str/dict): Request body data
+- `country` (str): Country code for proxy location (e.g., "US", "GB", "DE")
+- `session_id` (str): Session ID for sticky sessions
+
+### 2. ProxyClawSessionTool
+
+Sticky proxy sessions for multi-step workflows.
+
+```python
+from langchain_proxyclaw import ProxyClawSessionTool
+
+tool = ProxyClawSessionTool(api_key="your_api_key")
+
+# Scrape multiple pages with the same IP
+result = tool.invoke({
+    "urls": [
+        "https://site.com/login",
+        "https://site.com/dashboard",
+        "https://site.com/profile"
+    ],
+    "country": "US"
+})
+```
+
+**Parameters:**
+- `urls` (list[str], required): List of URLs to fetch
+- `country` (str): Country code
+- `session_lifetime` (int): Session duration in minutes - default: 30
+
+### 3. ProxyClawScraperTool
+
+Advanced scraper with retries and auto-rotation.
+
+```python
+from langchain_proxyclaw import ProxyClawScraperTool
+
+tool = ProxyClawScraperTool(api_key="your_api_key")
+
+# Scrape with retries and link extraction
+result = tool.invoke({
+    "url": "https://example.com/products",
+    "country": "US",
+    "retries": 3,
+    "timeout": 30,
+    "extract_links": True
+})
+```
+
+**Parameters:**
+- `url` (str, required): Target URL
+- `country` (str): Country code
+- `retries` (int): Number of retry attempts - default: 3
+- `timeout` (int): Request timeout in seconds - default: 30
+- `extract_links` (bool): Extract all links from the page - default: False
+
+## Authentication
+
+Get your API key from [ProxyClaw Dashboard](https://platform.proxyclaw.ai):
+
+```python
+api_key = "pk_live_xxxxxxxxxxxxxxxx"
+```
+
+## Country Codes
+
+Common country codes:
+- `US` - United States
+- `GB` - United Kingdom
+- `DE` - Germany
+- `FR` - France
+- `JP` - Japan
+- `IN` - India
+- `BR` - Brazil
+
+Full list: 111+ countries supported. Use ISO 3166-1 alpha-2 codes.
+
+## Use Cases
+
+### Web Scraping for AI Agents
+
+```python
+from langchain_proxyclaw import ProxyClawScraperTool
+from langchain.agents import AgentType, initialize_agent
+
+scraper = ProxyClawScraperTool(api_key="your_api_key")
+
+agent = initialize_agent(
+    [scraper],
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
+)
+
+# Agent can now scrape without being blocked
+agent.run("Find pricing information from https://competitor.com/pricing")
+```
+
+### E-commerce Monitoring
+
+```python
+session_tool = ProxyClawSessionTool(api_key="your_api_key")
+
+# Same IP for login + price check
+result = session_tool.invoke({
+    "urls": [
+        "https://shop.com/login",
+        "https://shop.com/product/123"
+    ],
+    "country": "US"
+})
+```
+
+### Market Research
+
+```python
+from langchain_proxyclaw import ProxyClawTool
+
+tool = ProxyClawTool(api_key="your_api_key")
+
+# Check how a site appears from different countries
+for country in ["US", "GB", "DE", "JP"]:
+    result = tool.invoke({
+        "url": "https://global-site.com",
+        "country": country
+    })
+    print(f"{country}: {result}")
+```
+
+## LangChain Integration Tests
+
+To run LangChain's standard integration tests:
+
+```bash
+pip install langchain-proxyclaw[dev]
+pytest tests/ -v
+```
+
+## Documentation
+
+Full documentation: [docs.proxyclaw.ai](https://docs.proxyclaw.ai)
+
+LangChain docs: [python.langchain.com](https://python.langchain.com)
+
+## API Reference
+
+See [ProxyClaw API Docs](https://docs.proxyclaw.ai/api) for details on:
+- Authentication formats
+- Country targeting
+- Session management
+- Bandwidth tracking
+
+## Pricing
+
+ProxyClaw uses pay-as-you-go pricing:
+- $0.35/GB under 10TB
+- $0.25/GB over 10TB
+
+No minimums, no commitments. [Sign up](https://proxyclaw.ai)
+
+## Support
+
+- 📧 Email: support@iploop.io
+- 💬 Discord: [discord.gg/clawd](https://discord.gg/clawd)
+- 📖 Docs: [docs.proxyclaw.ai](https://docs.proxyclaw.ai)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+## Contributing
+
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+---
+
+Built with ❤️ by the [IPLoop](https://iploop.io) team.

langchain_proxyclaw-0.1.0/langchain_proxyclaw/__init__.py

@@ -0,0 +1,14 @@
+"""LangChain integration for ProxyClaw residential proxy network."""
+
+from langchain_proxyclaw.tools import (
+    ProxyClawTool,
+    ProxyClawSessionTool,
+    ProxyClawScraperTool,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "ProxyClawTool",
+    "ProxyClawSessionTool",
+    "ProxyClawScraperTool",
+]

langchain_proxyclaw-0.1.0/langchain_proxyclaw/tools.py

@@ -0,0 +1,318 @@
+"""LangChain Tools for ProxyClaw proxy network."""
+
+from typing import Any, Dict, List, Optional, Type, Union
+from urllib.parse import urljoin, urlparse
+
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from iploop import IPLoop
+
+
+class ProxyClawRequestInput(BaseModel):
+    """Input schema for ProxyClaw HTTP request."""
+    url: str = Field(..., description="URL to fetch")
+    method: str = Field(default="GET", description="HTTP method (GET, POST, PUT, DELETE)")
+    headers: Optional[Dict[str, str]] = Field(default=None, description="Optional HTTP headers")
+    data: Optional[Union[Dict[str, Any], str]] = Field(default=None, description="Request body data")
+    country: Optional[str] = Field(default=None, description="Country code for proxy location (e.g., 'US', 'GB')")
+
+
+class ProxyClawSessionInput(BaseModel):
+    """Input schema for ProxyClaw sticky session."""
+    urls: List[str] = Field(..., description="List of URLs to fetch in the same session")
+    country: Optional[str] = Field(default=None, description="Country code for proxy location")
+
+
+class ProxyClawScraperInput(BaseModel):
+    """Input schema for ProxyClaw web scraper with retries."""
+    url: str = Field(..., description="URL to scrape")
+    country: Optional[str] = Field(default=None, description="Country code for proxy location")
+    retries: int = Field(default=3, description="Number of retry attempts")
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+    extract_links: bool = Field(default=False, description="Whether to extract links from the page")
+
+
+class ProxyClawTool(BaseTool):
+    """Tool for making HTTP requests through ProxyClaw residential proxies.
+    
+    This tool routes HTTP requests through ProxyClaw's residential proxy network,
+    providing access to 10M+ IPs across 111+ countries with anti-detection features.
+    
+    Example:
+        .. code-block:: python
+        
+            from langchain_proxyclaw import ProxyClawTool
+            
+            tool = ProxyClawTool(api_key="your_api_key")
+            result = tool.invoke({
+                "url": "https://example.com",
+                "country": "US"
+            })
+    """
+    
+    name: str = "proxyclaw_request"
+    description: str = (
+        "Make HTTP requests through ProxyClaw residential proxies. "
+        "Provides access to millions of residential IPs with anti-detection. "
+        "Input: URL, optional country code, headers. "
+        "Output: Response content, status code, headers."
+    )
+    args_schema: Type[BaseModel] = ProxyClawRequestInput
+    
+    client: Any = Field(default=None, exclude=True)
+    api_key: Optional[str] = Field(default=None, exclude=True)
+    
+    def __init__(self, api_key: Optional[str] = None, **kwargs: Any):
+        """Initialize ProxyClawTool.
+        
+        Args:
+            api_key: ProxyClaw API key
+            **kwargs: Additional arguments passed to BaseTool
+        """
+        super().__init__(**kwargs)
+        self.api_key = api_key
+        self.client = IPLoop(api_key=api_key) if api_key else None
+    
+    def _run(
+        self,
+        url: str,
+        method: str = "GET",
+        headers: Optional[Dict[str, str]] = None,
+        data: Optional[Union[Dict[str, Any], str]] = None,
+        country: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Execute HTTP request through ProxyClaw.
+        
+        Args:
+            url: Target URL
+            method: HTTP method
+            headers: Optional headers
+            data: Request body
+            country: Country code for proxy
+            run_manager: Callback manager
+            
+        Returns:
+            Response content as string
+        """
+        try:
+            if self.client is None:
+                return "Error: No API key provided"
+            
+            # Create new client with country if specified
+            client = self.client
+            if country:
+                client = IPLoop(api_key=self.api_key, country=country)
+            
+            # Make request
+            if method.upper() == "GET":
+                response = client.get(url, headers=headers)
+            elif method.upper() == "POST":
+                response = client.post(url, data=data, headers=headers)
+            elif method.upper() == "PUT":
+                response = client.put(url, data=data, headers=headers)
+            elif method.upper() == "DELETE":
+                response = client.delete(url, headers=headers)
+            else:
+                return f"Error: Unsupported method {method}"
+            
+            result = {
+                "status_code": response.status_code if hasattr(response, 'status_code') else 200,
+                "url": url,
+                "content": response.text[:10000] if hasattr(response, 'text') else str(response)[:10000],
+                "success": True,
+            }
+            
+            return str(result)
+            
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+
+class ProxyClawSessionTool(BaseTool):
+    """Tool for proxy sessions through ProxyClaw.
+    
+    Maintains session context across multiple requests.
+    
+    Example:
+        .. code-block:: python
+        
+            tool = ProxyClawSessionTool(api_key="your_api_key")
+            result = tool.invoke({
+                "urls": ["https://site.com/page1", "https://site.com/page2"],
+                "country": "GB"
+            })
+    """
+    
+    name: str = "proxyclaw_session"
+    description: str = (
+        "Create a proxy session for multiple requests. "
+        "Useful for sites requiring consistent IP (login, checkout, etc.). "
+        "Input: List of URLs, country. "
+        "Output: List of responses."
+    )
+    args_schema: Type[BaseModel] = ProxyClawSessionInput
+    
+    client: Any = Field(default=None, exclude=True)
+    api_key: Optional[str] = Field(default=None, exclude=True)
+    
+    def __init__(self, api_key: Optional[str] = None, **kwargs: Any):
+        super().__init__(**kwargs)
+        self.api_key = api_key
+        self.client = IPLoop(api_key=api_key) if api_key else None
+    
+    def _run(
+        self,
+        urls: List[str],
+        country: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Execute multiple requests in a session.
+        
+        Args:
+            urls: List of URLs to fetch
+            country: Country code
+            run_manager: Callback manager
+            
+        Returns:
+            Combined results as string
+        """
+        if self.client is None:
+            return "Error: No API key provided"
+        
+        results = []
+        
+        # Use session if available, otherwise create client with country
+        client = self.client
+        if country:
+            client = IPLoop(api_key=self.api_key, country=country)
+        
+        for url in urls:
+            try:
+                response = client.get(url)
+                results.append({
+                    "url": url,
+                    "status": response.status_code if hasattr(response, 'status_code') else 200,
+                    "success": True,
+                    "preview": response.text[:500] if hasattr(response, 'text') else str(response)[:500],
+                })
+            except Exception as e:
+                results.append({"url": url, "error": str(e)})
+        
+        return str({
+            "results": results,
+            "total": len(urls),
+            "successful": sum(1 for r in results if r.get("success")),
+        })
+
+
+class ProxyClawScraperTool(BaseTool):
+    """Advanced web scraper with retries.
+    
+    Automatically retries failed requests with different IPs
+    and can extract links and structured data.
+    
+    Example:
+        .. code-block:: python
+        
+            tool = ProxyClawScraperTool(api_key="your_api_key")
+            result = tool.invoke({
+                "url": "https://example.com/products",
+                "country": "US",
+                "retries": 3,
+                "extract_links": True
+            })
+    """
+    
+    name: str = "proxyclaw_scraper"
+    description: str = (
+        "Advanced web scraper with automatic retries and IP rotation. "
+        "Best for challenging sites with anti-bot protection. "
+        "Input: URL, country, retries, timeout, extract_links. "
+        "Output: Page content, extracted links, success status."
+    )
+    args_schema: Type[BaseModel] = ProxyClawScraperInput
+    
+    client: Any = Field(default=None, exclude=True)
+    api_key: Optional[str] = Field(default=None, exclude=True)
+    
+    def __init__(self, api_key: Optional[str] = None, **kwargs: Any):
+        super().__init__(**kwargs)
+        self.api_key = api_key
+        self.client = IPLoop(api_key=api_key) if api_key else None
+    
+    def _run(
+        self,
+        url: str,
+        country: Optional[str] = None,
+        retries: int = 3,
+        timeout: int = 30,
+        extract_links: bool = False,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Scrape URL with retries and optional link extraction.
+        
+        Args:
+            url: Target URL
+            country: Country code
+            retries: Number of retry attempts
+            timeout: Request timeout
+            extract_links: Whether to extract links
+            run_manager: Callback manager
+            
+        Returns:
+            Scraped data as string
+        """
+        if self.client is None:
+            return "Error: No API key provided"
+        
+        last_error = None
+        
+        for attempt in range(retries):
+            try:
+                # Create client with country if specified
+                client = self.client
+                if country:
+                    client = IPLoop(api_key=self.api_key, country=country)
+                
+                response = client.get(url)
+                
+                content = response.text if hasattr(response, 'text') else str(response)
+                result = {
+                    "url": url,
+                    "status_code": response.status_code if hasattr(response, 'status_code') else 200,
+                    "success": True,
+                    "attempts": attempt + 1,
+                    "content_length": len(content),
+                    "content_preview": content[:2000],
+                }
+                
+                if extract_links:
+                    try:
+                        from bs4 import BeautifulSoup
+                        soup = BeautifulSoup(content, 'html.parser')
+                        links = [a.get('href') for a in soup.find_all('a', href=True)]
+                        # Convert relative to absolute URLs
+                        base_url = f"{urlparse(url).scheme}://{urlparse(url).netloc}"
+                        links = [
+                            urljoin(base_url, link) if link.startswith('/') else link
+                            for link in links
+                        ]
+                        result["extracted_links"] = list(set(links))[:50]  # Limit links
+                    except ImportError:
+                        result["extracted_links"] = ["beautifulsoup4 not installed"]
+                
+                return str(result)
+                
+            except Exception as e:
+                last_error = str(e)
+                continue
+        
+        return str({
+            "url": url,
+            "success": False,
+            "attempts": retries,
+            "error": last_error,
+        })

langchain_proxyclaw-0.1.0/langchain_proxyclaw/utils.py

@@ -0,0 +1,76 @@
+"""Utility functions for langchain-proxyclaw."""
+
+from typing import Any, Dict, Optional
+
+
+def build_auth_string(
+    base_auth: str,
+    country: Optional[str] = None,
+    session_id: Optional[str] = None,
+    session_lifetime: Optional[int] = None,
+    city: Optional[str] = None,
+    rotation: bool = False,
+) -> str:
+    """Build ProxyClaw auth string with options.
+    
+    Args:
+        base_auth: Base auth string (customer_id:api_key)
+        country: Country code (e.g., 'US', 'GB')
+        session_id: Session ID for sticky sessions
+        session_lifetime: Session lifetime in minutes
+        city: City name for geo-targeting
+        rotation: Whether to enable IP rotation
+        
+    Returns:
+        Formatted auth string
+    """
+    auth = base_auth
+    
+    if country:
+        auth = f"{auth}-country-{country}"
+    
+    if city:
+        auth = f"{auth}-city-{city}"
+    
+    if session_id:
+        auth = f"{auth}-session-{session_id}"
+        if session_lifetime:
+            auth = f"{auth}-lifetime-{session_lifetime}"
+    
+    if rotation:
+        auth = f"{auth}-rotation-true"
+    
+    return auth
+
+
+def validate_url(url: str) -> bool:
+    """Validate URL format.
+    
+    Args:
+        url: URL to validate
+        
+    Returns:
+        True if valid URL
+    """
+    from urllib.parse import urlparse
+    
+    try:
+        result = urlparse(url)
+        return all([result.scheme in ('http', 'https'), result.netloc])
+    except Exception:
+        return False
+
+
+def truncate_content(content: str, max_length: int = 10000) -> str:
+    """Truncate content to max length with indicator.
+    
+    Args:
+        content: Content to truncate
+        max_length: Maximum length
+        
+    Returns:
+        Truncated content
+    """
+    if len(content) <= max_length:
+        return content
+    return content[:max_length] + f"\n... [truncated, total: {len(content)} chars]"

langchain_proxyclaw-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-proxyclaw"
+version = "0.1.0"
+description = "LangChain integration for ProxyClaw - residential proxy network"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "IPLoop Team", email = "support@iploop.io"}
+]
+keywords = ["langchain", "proxy", "scraping", "residential", "proxyclaw", "iploop"]
+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 :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "langchain-core>=0.1.0",
+    "iploop-sdk>=1.8.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "mypy>=1.0.0",
+    "beautifulsoup4>=4.12.0",
+]
+
+[project.urls]
+Homepage = "https://proxyclaw.ai"
+Documentation = "https://docs.proxyclaw.ai"
+Repository = "https://github.com/iploop/langchain-proxyclaw"
+"Bug Tracker" = "https://github.com/iploop/langchain-proxyclaw/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_proxyclaw"]
+
+[tool.black]
+line-length = 100
+target-version = ['py39']
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true

langchain_proxyclaw-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for langchain-proxyclaw."""

langchain_proxyclaw-0.1.0/tests/test_tools.py

@@ -0,0 +1,153 @@
+"""Tests for ProxyClaw LangChain tools."""
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+from langchain_proxyclaw import ProxyClawTool, ProxyClawSessionTool, ProxyClawScraperTool
+
+
+class MockResponse:
+    """Mock HTTP response."""
+    def __init__(self, status_code=200, text="test content", url="https://example.com"):
+        self.status_code = status_code
+        self.text = text
+        self.url = url
+        self.headers = {"Content-Type": "text/html"}
+
+
+@pytest.fixture
+def mock_iploop():
+    """Fixture for mocked IPLoop client."""
+    with patch("langchain_proxyclaw.tools.IPLoop") as mock:
+        instance = MagicMock()
+        mock.return_value = instance
+        yield instance
+
+
+class TestProxyClawTool:
+    """Tests for ProxyClawTool."""
+    
+    def test_initialization(self):
+        """Test tool initialization."""
+        tool = ProxyClawTool(api_key="test_key")
+        assert tool.name == "proxyclaw_request"
+        assert tool.api_key == "test_key"
+    
+    def test_basic_request(self, mock_iploop):
+        """Test basic HTTP request."""
+        mock_iploop.get.return_value = MockResponse()
+        
+        tool = ProxyClawTool(api_key="test_key")
+        result = tool._run(url="https://example.com")
+        
+        assert "status_code" in result
+        assert "200" in result or "success" in result
+        mock_iploop.get.assert_called_once()
+    
+    def test_request_with_country(self, mock_iploop):
+        """Test request with country parameter."""
+        mock_iploop.get.return_value = MockResponse()
+        
+        tool = ProxyClawTool(api_key="test_key")
+        result = tool._run(url="https://example.com", country="US")
+        
+        # Should succeed - country param is processed
+        assert "status_code" in result or "success" in result
+    
+    def test_post_request(self, mock_iploop):
+        """Test POST request."""
+        mock_iploop.post.return_value = MockResponse()
+        
+        tool = ProxyClawTool(api_key="test_key")
+        result = tool._run(
+            url="https://example.com/api",
+            method="POST",
+            data={"key": "value"}
+        )
+        
+        mock_iploop.post.assert_called_once()
+
+
+class TestProxyClawSessionTool:
+    """Tests for ProxyClawSessionTool."""
+    
+    def test_initialization(self):
+        """Test tool initialization."""
+        tool = ProxyClawSessionTool(api_key="test_key")
+        assert tool.name == "proxyclaw_session"
+    
+    def test_session_requests(self, mock_iploop):
+        """Test multiple requests in session."""
+        mock_iploop.get.return_value = MockResponse()
+        
+        tool = ProxyClawSessionTool(api_key="test_key")
+        result = tool._run(
+            urls=["https://example.com/1", "https://example.com/2"],
+            country="GB"
+        )
+        
+        assert mock_iploop.get.call_count == 2
+        assert "results" in result
+
+
+class TestProxyClawScraperTool:
+    """Tests for ProxyClawScraperTool."""
+    
+    def test_initialization(self):
+        """Test tool initialization."""
+        tool = ProxyClawScraperTool(api_key="test_key")
+        assert tool.name == "proxyclaw_scraper"
+    
+    def test_successful_scrape(self, mock_iploop):
+        """Test successful scraping."""
+        mock_iploop.get.return_value = MockResponse(
+            text='<html><body><a href="/page2">Link</a></body></html>'
+        )
+        
+        tool = ProxyClawScraperTool(api_key="test_key")
+        result = tool._run(url="https://example.com")
+        
+        assert "success" in result
+        assert "True" in result
+    
+    def test_scrape_with_retries(self, mock_iploop):
+        """Test scraping with retry logic."""
+        # First call fails, second succeeds
+        mock_iploop.get.side_effect = [
+            Exception("Connection error"),
+            MockResponse()
+        ]
+        
+        tool = ProxyClawScraperTool(api_key="test_key")
+        result = tool._run(url="https://example.com", retries=2)
+        
+        assert mock_iploop.get.call_count == 2
+
+
+class TestToolSchema:
+    """Tests for tool input schemas."""
+    
+    def test_proxyclaw_tool_schema(self):
+        """Test ProxyClawTool schema."""
+        tool = ProxyClawTool()
+        schema = tool.args_schema
+        
+        assert "url" in schema.model_fields
+        assert "method" in schema.model_fields
+        assert "country" in schema.model_fields
+    
+    def test_session_tool_schema(self):
+        """Test ProxyClawSessionTool schema."""
+        tool = ProxyClawSessionTool()
+        schema = tool.args_schema
+        
+        assert "urls" in schema.model_fields
+    
+    def test_scraper_tool_schema(self):
+        """Test ProxyClawScraperTool schema."""
+        tool = ProxyClawScraperTool()
+        schema = tool.args_schema
+        
+        assert "url" in schema.model_fields
+        assert "retries" in schema.model_fields
+        assert "extract_links" in schema.model_fields