langchain-apiverve 0.1.0__tar.gz

langchain_apiverve-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 EvlarSoft LLC and APIVerve
+
+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_apiverve-0.1.0/PKG-INFO

@@ -0,0 +1,285 @@
+Metadata-Version: 2.4
+Name: langchain-apiverve
+Version: 0.1.0
+Summary: LangChain integration for APIVerve - Access 310+ utility APIs for AI agents
+License: MIT
+License-File: LICENSE
+Keywords: langchain,langchain-integration,apiverve,api,ai,llm,agents,tools,validation,utilities
+Author: APIVerve
+Author-email: hello@apiverve.com
+Requires-Python: >=3.9
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: dev
+Requires-Dist: langchain-core (>=0.2.0)
+Requires-Dist: mypy (>=1.0.0) ; extra == "dev"
+Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: pytest (>=7.0.0) ; extra == "dev"
+Requires-Dist: pytest-asyncio (>=0.21.0) ; extra == "dev"
+Requires-Dist: requests (>=2.28.0)
+Requires-Dist: ruff (>=0.1.0) ; extra == "dev"
+Project-URL: Changelog, https://github.com/apiverve/langchain-apiverve/releases
+Project-URL: Documentation, https://docs.apiverve.com
+Project-URL: Homepage, https://apiverve.com
+Project-URL: Issues, https://github.com/apiverve/langchain-apiverve/issues
+Project-URL: Repository, https://github.com/apiverve/langchain-apiverve
+Description-Content-Type: text/markdown
+
+# langchain-apiverve
+
+[![PyPI version](https://img.shields.io/pypi/v/langchain-apiverve.svg)](https://pypi.org/project/langchain-apiverve/)
+[![Python versions](https://img.shields.io/pypi/pyversions/langchain-apiverve.svg)](https://pypi.org/project/langchain-apiverve/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![LangChain](https://img.shields.io/badge/LangChain-Integration-blue)](https://python.langchain.com/)
+
+**LangChain integration for [APIVerve](https://apiverve.com)** - Access 310+ utility APIs for AI agents and LLM applications.
+
+Build powerful AI agents with access to validation, conversion, generation, analysis, and lookup APIs.
+
+---
+
+## Features
+
+- **310+ APIs** - Email validation, DNS lookup, IP geolocation, QR codes, currency conversion, and more
+- **29 Categories** - Data Lookup, News, Domain Data, Data Conversion, Entertainment, and more
+- **LangChain Native** - Works with any LangChain agent or chain
+- **Type Safe** - Full Pydantic schemas for inputs and outputs
+- **Async Support** - Both sync and async API calls
+- **Flexible** - Use individual tools or the "run any" meta-tool
+
+---
+
+## Installation
+
+```bash
+pip install langchain-apiverve
+```
+
+## Quick Start
+
+```python
+from langchain_apiverve import APIVerveToolkit
+from langchain_openai import ChatOpenAI
+from langchain.agents import create_tool_calling_agent, AgentExecutor
+from langchain_core.prompts import ChatPromptTemplate
+
+# Initialize toolkit with your API key
+toolkit = APIVerveToolkit(api_key="your-api-key")
+# Or set APIVERVE_API_KEY environment variable
+
+# Get tools
+tools = toolkit.get_tools()
+
+# Create an agent
+llm = ChatOpenAI(model="gpt-4")
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant with access to various utility APIs."),
+    ("human", "{input}"),
+    ("placeholder", "{agent_scratchpad}"),
+])
+
+agent = create_tool_calling_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+# Use the agent
+result = executor.invoke({"input": "Is test@example.com a valid email?"})
+print(result["output"])
+```
+
+---
+
+## Usage Examples
+
+### Using Individual Tools
+
+```python
+from langchain_apiverve import APIVerveToolkit
+
+toolkit = APIVerveToolkit(api_key="your-api-key")
+
+# Get specific tools
+tools = toolkit.get_tools(include_apis=["emailvalidator", "dnslookup"])
+
+# Use a tool directly
+email_tool = tools[0]
+result = email_tool.invoke({"email": "user@example.com"})
+print(result)
+```
+
+### Using the "Run Any" Tool
+
+```python
+from langchain_apiverve import APIVerveToolkit
+
+toolkit = APIVerveToolkit(api_key="your-api-key")
+
+# Get the flexible run-any tool
+run_any = toolkit.get_run_any_tool()
+
+# Call any API dynamically
+result = run_any.invoke({
+    "api_id": "qrcodegenerator",
+    "parameters": {"value": "https://example.com"}
+})
+print(result)
+```
+
+### Filtering Tools by Category
+
+```python
+from langchain_apiverve import APIVerveToolkit
+
+toolkit = APIVerveToolkit(api_key="your-api-key")
+
+# Get only validation tools
+validation_tools = toolkit.get_tools(categories=["Validation"])
+
+# Get only lookup tools
+lookup_tools = toolkit.get_tools(categories=["Lookup"])
+```
+
+### Low-Level Client Usage
+
+```python
+from langchain_apiverve import APIVerveClient
+
+client = APIVerveClient(api_key="your-api-key")
+
+# Make API calls directly
+result = client.call_api("emailvalidator", {"email": "test@example.com"})
+print(result)
+
+# Async usage
+import asyncio
+
+async def main():
+    result = await client.acall_api("dnslookup", {"domain": "example.com"})
+    print(result)
+
+asyncio.run(main())
+```
+
+---
+
+## Available APIs
+
+APIVerve provides 310+ APIs across 29 categories:
+
+| Category | APIs | Examples |
+|----------|------|----------|
+| **Data Lookup** | 15 | World Time, Thesaurus, Emoji Lookup |
+| **News** | 1 | World News |
+| **Domain Data** | 15 | DNS Lookup, WHOIS Lookup, SSL Certificate Checker |
+| **Data Conversion** | 32 | Unit Converter, Number to Words, Words to Numbers |
+| **Entertainment** | 24 | Chuck Norris Jokes, Historical Events, Random Facts |
+| **Weather** | 8 | Air Quality, Marine Weather, Weather |
+| **Science** | 4 | Meteorite Landings, Stars Lookup, Periodic Table |
+| **Finance** | 13 | Mortgage Calculator, Loan Calculator, Currency Symbols |
+| **Transportation** | 4 | Airports Lookup, Airline Lookup, Car Models |
+| **Data Generation** | 32 | Baby Name Generator, Random Word, Random User Generator |
+
+[Browse all APIs →](https://apiverve.com/marketplace)
+
+---
+
+## API Response Format
+
+All APIVerve APIs return a consistent response format:
+
+```json
+{
+  "status": "ok",
+  "error": null,
+  "data": {
+    // API-specific response data
+  }
+}
+```
+
+---
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `APIVERVE_API_KEY` | Your APIVerve API key |
+
+### Toolkit Options
+
+```python
+toolkit = APIVerveToolkit(
+    api_key="...",           # API key (or use env var)
+    base_url="...",          # Custom API base URL
+)
+
+tools = toolkit.get_tools(
+    categories=["..."],      # Filter by category
+    include_apis=["..."],    # Only include specific APIs
+    exclude_apis=["..."],    # Exclude specific APIs
+    include_run_any=True,    # Include the "run any" tool
+    include_popular=True,    # Include pre-built popular tools
+)
+```
+
+---
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/apiverve/langchain-apiverve.git
+cd langchain-apiverve
+
+# Install with Poetry
+poetry install
+
+# Or with pip
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Linting
+
+```bash
+ruff check .
+mypy src/
+```
+
+---
+
+## Resources
+
+| Resource | Link |
+|----------|------|
+| APIVerve Website | [apiverve.com](https://apiverve.com) |
+| API Documentation | [docs.apiverve.com](https://docs.apiverve.com) |
+| API Marketplace | [apiverve.com/marketplace](https://apiverve.com/marketplace) |
+| LangChain Docs | [python.langchain.com](https://python.langchain.com) |
+| GitHub Issues | [github.com/apiverve/langchain-apiverve/issues](https://github.com/apiverve/langchain-apiverve/issues) |
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+Copyright (c) 2025 [APIVerve](https://apiverve.com)
+

langchain_apiverve-0.1.0/README.md

@@ -0,0 +1,248 @@
+# langchain-apiverve
+
+[![PyPI version](https://img.shields.io/pypi/v/langchain-apiverve.svg)](https://pypi.org/project/langchain-apiverve/)
+[![Python versions](https://img.shields.io/pypi/pyversions/langchain-apiverve.svg)](https://pypi.org/project/langchain-apiverve/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![LangChain](https://img.shields.io/badge/LangChain-Integration-blue)](https://python.langchain.com/)
+
+**LangChain integration for [APIVerve](https://apiverve.com)** - Access 310+ utility APIs for AI agents and LLM applications.
+
+Build powerful AI agents with access to validation, conversion, generation, analysis, and lookup APIs.
+
+---
+
+## Features
+
+- **310+ APIs** - Email validation, DNS lookup, IP geolocation, QR codes, currency conversion, and more
+- **29 Categories** - Data Lookup, News, Domain Data, Data Conversion, Entertainment, and more
+- **LangChain Native** - Works with any LangChain agent or chain
+- **Type Safe** - Full Pydantic schemas for inputs and outputs
+- **Async Support** - Both sync and async API calls
+- **Flexible** - Use individual tools or the "run any" meta-tool
+
+---
+
+## Installation
+
+```bash
+pip install langchain-apiverve
+```
+
+## Quick Start
+
+```python
+from langchain_apiverve import APIVerveToolkit
+from langchain_openai import ChatOpenAI
+from langchain.agents import create_tool_calling_agent, AgentExecutor
+from langchain_core.prompts import ChatPromptTemplate
+
+# Initialize toolkit with your API key
+toolkit = APIVerveToolkit(api_key="your-api-key")
+# Or set APIVERVE_API_KEY environment variable
+
+# Get tools
+tools = toolkit.get_tools()
+
+# Create an agent
+llm = ChatOpenAI(model="gpt-4")
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant with access to various utility APIs."),
+    ("human", "{input}"),
+    ("placeholder", "{agent_scratchpad}"),
+])
+
+agent = create_tool_calling_agent(llm, tools, prompt)
+executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+# Use the agent
+result = executor.invoke({"input": "Is test@example.com a valid email?"})
+print(result["output"])
+```
+
+---
+
+## Usage Examples
+
+### Using Individual Tools
+
+```python
+from langchain_apiverve import APIVerveToolkit
+
+toolkit = APIVerveToolkit(api_key="your-api-key")
+
+# Get specific tools
+tools = toolkit.get_tools(include_apis=["emailvalidator", "dnslookup"])
+
+# Use a tool directly
+email_tool = tools[0]
+result = email_tool.invoke({"email": "user@example.com"})
+print(result)
+```
+
+### Using the "Run Any" Tool
+
+```python
+from langchain_apiverve import APIVerveToolkit
+
+toolkit = APIVerveToolkit(api_key="your-api-key")
+
+# Get the flexible run-any tool
+run_any = toolkit.get_run_any_tool()
+
+# Call any API dynamically
+result = run_any.invoke({
+    "api_id": "qrcodegenerator",
+    "parameters": {"value": "https://example.com"}
+})
+print(result)
+```
+
+### Filtering Tools by Category
+
+```python
+from langchain_apiverve import APIVerveToolkit
+
+toolkit = APIVerveToolkit(api_key="your-api-key")
+
+# Get only validation tools
+validation_tools = toolkit.get_tools(categories=["Validation"])
+
+# Get only lookup tools
+lookup_tools = toolkit.get_tools(categories=["Lookup"])
+```
+
+### Low-Level Client Usage
+
+```python
+from langchain_apiverve import APIVerveClient
+
+client = APIVerveClient(api_key="your-api-key")
+
+# Make API calls directly
+result = client.call_api("emailvalidator", {"email": "test@example.com"})
+print(result)
+
+# Async usage
+import asyncio
+
+async def main():
+    result = await client.acall_api("dnslookup", {"domain": "example.com"})
+    print(result)
+
+asyncio.run(main())
+```
+
+---
+
+## Available APIs
+
+APIVerve provides 310+ APIs across 29 categories:
+
+| Category | APIs | Examples |
+|----------|------|----------|
+| **Data Lookup** | 15 | World Time, Thesaurus, Emoji Lookup |
+| **News** | 1 | World News |
+| **Domain Data** | 15 | DNS Lookup, WHOIS Lookup, SSL Certificate Checker |
+| **Data Conversion** | 32 | Unit Converter, Number to Words, Words to Numbers |
+| **Entertainment** | 24 | Chuck Norris Jokes, Historical Events, Random Facts |
+| **Weather** | 8 | Air Quality, Marine Weather, Weather |
+| **Science** | 4 | Meteorite Landings, Stars Lookup, Periodic Table |
+| **Finance** | 13 | Mortgage Calculator, Loan Calculator, Currency Symbols |
+| **Transportation** | 4 | Airports Lookup, Airline Lookup, Car Models |
+| **Data Generation** | 32 | Baby Name Generator, Random Word, Random User Generator |
+
+[Browse all APIs →](https://apiverve.com/marketplace)
+
+---
+
+## API Response Format
+
+All APIVerve APIs return a consistent response format:
+
+```json
+{
+  "status": "ok",
+  "error": null,
+  "data": {
+    // API-specific response data
+  }
+}
+```
+
+---
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `APIVERVE_API_KEY` | Your APIVerve API key |
+
+### Toolkit Options
+
+```python
+toolkit = APIVerveToolkit(
+    api_key="...",           # API key (or use env var)
+    base_url="...",          # Custom API base URL
+)
+
+tools = toolkit.get_tools(
+    categories=["..."],      # Filter by category
+    include_apis=["..."],    # Only include specific APIs
+    exclude_apis=["..."],    # Exclude specific APIs
+    include_run_any=True,    # Include the "run any" tool
+    include_popular=True,    # Include pre-built popular tools
+)
+```
+
+---
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/apiverve/langchain-apiverve.git
+cd langchain-apiverve
+
+# Install with Poetry
+poetry install
+
+# Or with pip
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Linting
+
+```bash
+ruff check .
+mypy src/
+```
+
+---
+
+## Resources
+
+| Resource | Link |
+|----------|------|
+| APIVerve Website | [apiverve.com](https://apiverve.com) |
+| API Documentation | [docs.apiverve.com](https://docs.apiverve.com) |
+| API Marketplace | [apiverve.com/marketplace](https://apiverve.com/marketplace) |
+| LangChain Docs | [python.langchain.com](https://python.langchain.com) |
+| GitHub Issues | [github.com/apiverve/langchain-apiverve/issues](https://github.com/apiverve/langchain-apiverve/issues) |
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+Copyright (c) 2025 [APIVerve](https://apiverve.com)

langchain_apiverve-0.1.0/pyproject.toml

@@ -0,0 +1,98 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "langchain-apiverve"
+version = "0.1.0"
+description = "LangChain integration for APIVerve - Access 310+ utility APIs for AI agents"
+readme = "README.md"
+authors = [
+    {name = "APIVerve", email = "hello@apiverve.com"}
+]
+license = {text = "MIT"}
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "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 :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+keywords = [
+    "langchain",
+    "langchain-integration",
+    "apiverve",
+    "api",
+    "ai",
+    "llm",
+    "agents",
+    "tools",
+    "validation",
+    "utilities"
+]
+dependencies = [
+    "langchain-core>=0.2.0",
+    "requests>=2.28.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://apiverve.com"
+Documentation = "https://docs.apiverve.com"
+Repository = "https://github.com/apiverve/langchain-apiverve"
+Changelog = "https://github.com/apiverve/langchain-apiverve/releases"
+Issues = "https://github.com/apiverve/langchain-apiverve/issues"
+
+[tool.poetry]
+name = "langchain-apiverve"
+version = "0.1.0"
+description = "LangChain integration for APIVerve - Access 310+ utility APIs for AI agents"
+authors = ["APIVerve <hello@apiverve.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{include = "langchain_apiverve", from = "src"}]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+langchain-core = ">=0.2.0"
+requests = ">=2.28.0"
+pydantic = ">=2.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=7.0.0"
+pytest-asyncio = ">=0.21.0"
+ruff = ">=0.1.0"
+mypy = ">=1.0.0"
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

langchain_apiverve-0.1.0/src/langchain_apiverve/__init__.py

@@ -0,0 +1,31 @@
+"""
+LangChain integration for APIVerve.
+
+Dynamically loads 300+ utility APIs including validation, conversion,
+generation, analysis, and lookup tools for AI agents.
+
+Schemas are fetched from APIVerve at initialization and cached in memory
+for the lifetime of the process.
+
+Example:
+    >>> from langchain_apiverve import APIVerveToolkit
+    >>> toolkit = APIVerveToolkit(api_key="your-api-key")
+    >>> tools = toolkit.get_tools()  # All 300+ tools with proper schemas!
+    >>> # Use tools with any LangChain agent
+
+For more information, see: https://docs.apiverve.com
+"""
+
+from langchain_apiverve.toolkit import APIVerveToolkit, DynamicAPIVerveTool, load_api_schemas
+from langchain_apiverve.client import APIVerveClient, APIVerveError
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "APIVerveToolkit",
+    "DynamicAPIVerveTool",
+    "APIVerveClient",
+    "APIVerveError",
+    "load_api_schemas",
+    "__version__",
+]

langchain_apiverve-0.1.0/src/langchain_apiverve/client.py

@@ -0,0 +1,145 @@
+"""
+APIVerve API Client.
+
+Low-level client for making API requests to APIVerve.
+"""
+
+import asyncio
+from typing import Any, Dict, Optional
+from concurrent.futures import ThreadPoolExecutor
+
+import requests
+
+
+class APIVerveError(Exception):
+    """Base exception for APIVerve errors."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None, response: Optional[dict] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class APIVerveClient:
+    """
+    Client for making requests to APIVerve APIs.
+
+    Example:
+        >>> client = APIVerveClient(api_key="your-api-key")
+        >>> result = client.call_api("emailvalidator", {"email": "test@example.com"})
+        >>> print(result)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.apiverve.com/v1",
+        timeout: int = 30,
+    ):
+        """
+        Initialize the APIVerve client.
+
+        Args:
+            api_key: Your APIVerve API key
+            base_url: Base URL for API requests
+            timeout: Request timeout in seconds
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+        self._session: Optional[requests.Session] = None
+        self._executor = ThreadPoolExecutor(max_workers=4)
+
+    @property
+    def session(self) -> requests.Session:
+        """Get or create the requests session."""
+        if self._session is None:
+            self._session = requests.Session()
+            self._session.headers.update({
+                "x-api-key": self.api_key,
+                "Accept": "application/json",
+                "User-Agent": "langchain-apiverve/0.1.0",
+            })
+        return self._session
+
+    def call_api(
+        self,
+        api_id: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        method: str = "GET",
+    ) -> Dict[str, Any]:
+        """
+        Call an APIVerve API synchronously.
+
+        Args:
+            api_id: The API identifier (e.g., "emailvalidator", "dnslookup")
+            parameters: Parameters to pass to the API
+            method: HTTP method (GET or POST)
+
+        Returns:
+            API response as a dictionary
+
+        Raises:
+            APIVerveError: If the API call fails
+        """
+        url = f"{self.base_url}/{api_id}"
+        params = parameters or {}
+
+        try:
+            if method.upper() == "POST":
+                response = self.session.post(url, json=params, timeout=self.timeout)
+            else:
+                response = self.session.get(url, params=params, timeout=self.timeout)
+
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            error_msg = f"API request failed: {e}"
+            try:
+                error_response = response.json()
+                if "error" in error_response:
+                    error_msg = error_response["error"]
+            except Exception:
+                pass
+            raise APIVerveError(error_msg, status_code=response.status_code)
+        except requests.exceptions.RequestException as e:
+            raise APIVerveError(f"Request failed: {e}")
+
+    async def acall_api(
+        self,
+        api_id: str,
+        parameters: Optional[Dict[str, Any]] = None,
+        method: str = "GET",
+    ) -> Dict[str, Any]:
+        """
+        Call an APIVerve API asynchronously.
+
+        Args:
+            api_id: The API identifier (e.g., "emailvalidator", "dnslookup")
+            parameters: Parameters to pass to the API
+            method: HTTP method (GET or POST)
+
+        Returns:
+            API response as a dictionary
+
+        Raises:
+            APIVerveError: If the API call fails
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            self._executor,
+            lambda: self.call_api(api_id, parameters, method)
+        )
+
+    def close(self):
+        """Close the client and release resources."""
+        if self._session:
+            self._session.close()
+            self._session = None
+        self._executor.shutdown(wait=False)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

langchain_apiverve-0.1.0/src/langchain_apiverve/schemas.py

@@ -0,0 +1,50 @@
+"""
+Pydantic schemas for APIVerve API inputs and outputs.
+
+These schemas provide type safety and validation for API parameters.
+"""
+
+from typing import Any, Dict, Optional, List
+from pydantic import BaseModel, Field
+
+
+class APIResponse(BaseModel):
+    """Standard APIVerve API response format."""
+
+    status: str = Field(description="Response status: 'ok' or 'error'")
+    error: Optional[str] = Field(default=None, description="Error message if status is 'error'")
+    data: Optional[Dict[str, Any]] = Field(default=None, description="Response data")
+
+
+class EmailValidationResult(BaseModel):
+    """Result of email validation."""
+
+    valid: bool = Field(description="Whether the email is valid")
+    email: str = Field(description="The email address that was validated")
+    domain: Optional[str] = Field(default=None, description="The email domain")
+    disposable: Optional[bool] = Field(default=None, description="Whether the email is from a disposable provider")
+    mx_found: Optional[bool] = Field(default=None, description="Whether MX records were found")
+    syntax_valid: Optional[bool] = Field(default=None, description="Whether the email syntax is valid")
+
+
+class DNSRecord(BaseModel):
+    """A DNS record."""
+
+    type: str = Field(description="Record type (A, AAAA, MX, TXT, etc.)")
+    value: str = Field(description="Record value")
+    ttl: Optional[int] = Field(default=None, description="Time to live in seconds")
+    priority: Optional[int] = Field(default=None, description="Priority (for MX records)")
+
+
+class IPGeolocationResult(BaseModel):
+    """Result of IP geolocation lookup."""
+
+    ip: str = Field(description="The IP address")
+    country: Optional[str] = Field(default=None, description="Country name")
+    country_code: Optional[str] = Field(default=None, description="ISO country code")
+    region: Optional[str] = Field(default=None, description="Region/state name")
+    city: Optional[str] = Field(default=None, description="City name")
+    latitude: Optional[float] = Field(default=None, description="Latitude coordinate")
+    longitude: Optional[float] = Field(default=None, description="Longitude coordinate")
+    timezone: Optional[str] = Field(default=None, description="Timezone")
+    isp: Optional[str] = Field(default=None, description="Internet Service Provider")

langchain_apiverve-0.1.0/src/langchain_apiverve/toolkit.py

@@ -0,0 +1,305 @@
+"""
+APIVerve Toolkit for LangChain.
+
+Provides a convenient way to get all APIVerve tools for use with LangChain agents.
+Schemas are fetched from APIVerve at initialization time.
+"""
+
+import os
+from typing import Any, Dict, List, Optional, Type
+
+import requests
+from pydantic import BaseModel, Field, create_model
+from langchain_core.tools import BaseTool
+from langchain_core.callbacks import CallbackManagerForToolRun
+
+from langchain_apiverve.client import APIVerveClient
+
+
+# Schema source URL - always fetched fresh at init
+SCHEMA_URL = "https://api.apiverve.com/publicapis/mcp-schemas.json"
+
+# Module-level cache for schemas (persists for the lifetime of the process)
+_schemas_cache: Optional[Dict] = None
+
+
+def load_api_schemas(force_refresh: bool = False) -> Dict:
+    """
+    Load API schemas from APIVerve.
+
+    Schemas are cached in memory after the first fetch. Subsequent calls
+    return the cached schemas unless force_refresh=True.
+
+    Args:
+        force_refresh: Force re-fetch even if schemas are already cached.
+
+    Returns:
+        Dict with 'schemas' and 'totalAPIs' keys.
+
+    Raises:
+        RuntimeError: If schemas cannot be fetched from APIVerve.
+    """
+    global _schemas_cache
+
+    # Return cached if available and not forcing refresh
+    if _schemas_cache is not None and not force_refresh:
+        return _schemas_cache
+
+    # Fetch schemas from APIVerve (required - no fallback)
+    try:
+        response = requests.get(SCHEMA_URL, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+
+        if not data.get("schemas"):
+            raise ValueError("Response missing 'schemas' field")
+
+        _schemas_cache = data
+        return _schemas_cache
+
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(
+            f"Failed to fetch API schemas from {SCHEMA_URL}: {e}. "
+            "APIVerve schema endpoint must be accessible to use this toolkit."
+        ) from e
+    except (ValueError, KeyError) as e:
+        raise RuntimeError(
+            f"Invalid schema response from {SCHEMA_URL}: {e}"
+        ) from e
+
+
+def _python_type_from_schema(param_type: str) -> Type:
+    """Convert JSON schema type to Python type."""
+    type_map = {
+        "string": str,
+        "integer": int,
+        "number": float,
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+    }
+    return type_map.get(param_type, str)
+
+
+def _create_pydantic_model(api_schema: Dict) -> Type[BaseModel]:
+    """Dynamically create a Pydantic model from API schema."""
+    api_id = api_schema.get("apiId", "unknown")
+    parameters = api_schema.get("parameters", [])
+
+    if not parameters:
+        # No parameters - create empty model
+        return create_model(f"{api_id}Input")
+
+    # Build field definitions
+    fields = {}
+    for param in parameters:
+        name = param.get("name", "")
+        param_type = _python_type_from_schema(param.get("type", "string"))
+        required = param.get("required", False)
+        description = param.get("description", "")
+        example = param.get("example")
+
+        # Add example to description if available
+        if example:
+            description = f"{description} (e.g., {example})"
+
+        if required:
+            fields[name] = (param_type, Field(description=description))
+        else:
+            fields[name] = (Optional[param_type], Field(default=None, description=description))
+
+    return create_model(f"{api_id}Input", **fields)
+
+
+class DynamicAPIVerveTool(BaseTool):
+    """A dynamically-created tool for a specific APIVerve API."""
+
+    name: str = Field(description="The tool name")
+    description: str = Field(description="What the tool does")
+    api_id: str = Field(description="The APIVerve API identifier")
+    method: str = Field(default="GET", description="HTTP method")
+    client: APIVerveClient = Field(description="The API client")
+    args_schema: Type[BaseModel] = Field(description="The input schema")
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def _run(
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Execute the API call."""
+        # Filter out None values
+        params = {k: v for k, v in kwargs.items() if v is not None}
+        return self.client.call_api(self.api_id, params, method=self.method)
+
+
+class APIVerveToolkit:
+    """
+    Toolkit for accessing APIVerve APIs through LangChain.
+
+    Dynamically loads API schemas and creates properly-typed tools.
+    Schemas are fetched from APIVerve at initialization and cached in memory.
+
+    Example:
+        >>> from langchain_apiverve import APIVerveToolkit
+        >>>
+        >>> # Initialize with API key
+        >>> toolkit = APIVerveToolkit(api_key="your-api-key")
+        >>>
+        >>> # Or use environment variable APIVERVE_API_KEY
+        >>> toolkit = APIVerveToolkit()
+        >>>
+        >>> # Get all tools (with full parameter schemas!)
+        >>> tools = toolkit.get_tools()
+        >>>
+        >>> # Get tools for specific categories
+        >>> validation_tools = toolkit.get_tools(categories=["Validation"])
+        >>>
+        >>> # Get only specific APIs
+        >>> selected_tools = toolkit.get_tools(
+        ...     include_apis=["emailvalidator", "dnslookup", "iplookup"]
+        ... )
+
+    Args:
+        api_key: APIVerve API key. If not provided, uses APIVERVE_API_KEY env var.
+        base_url: Base URL for API calls. Defaults to https://api.apiverve.com/v1
+        refresh_schemas: Force re-fetch schemas even if already cached. Default False.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.apiverve.com/v1",
+        refresh_schemas: bool = False,
+    ):
+        self.api_key = api_key or os.environ.get("APIVERVE_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "API key is required. Provide api_key parameter or set APIVERVE_API_KEY environment variable. "
+                "Get your API key at https://dashboard.apiverve.com"
+            )
+
+        self.client = APIVerveClient(api_key=self.api_key, base_url=base_url)
+
+        # Load API schemas (cached)
+        schema_data = load_api_schemas(force_refresh=refresh_schemas)
+        self._schemas = schema_data.get("schemas", {})
+        self._total_apis = schema_data.get("totalAPIs", len(self._schemas))
+
+    def get_tools(
+        self,
+        categories: Optional[List[str]] = None,
+        include_apis: Optional[List[str]] = None,
+        exclude_apis: Optional[List[str]] = None,
+        max_tools: Optional[int] = None,
+    ) -> List[BaseTool]:
+        """
+        Get LangChain tools for APIVerve APIs.
+
+        Each tool has a properly-typed schema based on the API's parameters,
+        so the LLM knows exactly what arguments to pass.
+
+        Args:
+            categories: Only include APIs from these categories.
+            include_apis: Only include these specific API IDs.
+            exclude_apis: Exclude these specific API IDs.
+            max_tools: Maximum number of tools to return (for token limits).
+
+        Returns:
+            List of LangChain BaseTool instances with proper schemas.
+        """
+        tools: List[BaseTool] = []
+        exclude_set = set(exclude_apis or [])
+
+        for api_id, schema in self._schemas.items():
+            # Skip if excluded
+            if api_id in exclude_set:
+                continue
+
+            # Filter by category
+            if categories and schema.get("category") not in categories:
+                continue
+
+            # Filter by include list
+            if include_apis and api_id not in include_apis:
+                continue
+
+            # Create tool with dynamic schema
+            try:
+                tool = self._create_tool(schema)
+                tools.append(tool)
+            except Exception:
+                # Skip APIs that fail to create (malformed schema, etc.)
+                continue
+
+            # Respect max_tools limit
+            if max_tools and len(tools) >= max_tools:
+                break
+
+        return tools
+
+    def _create_tool(self, schema: Dict) -> DynamicAPIVerveTool:
+        """Create a tool from an API schema."""
+        api_id = schema.get("apiId", "")
+        title = schema.get("title", api_id)
+        description = schema.get("description", f"Execute the {title} API")
+        methods = schema.get("methods", ["GET"])
+        method = methods[0] if methods else "GET"
+
+        # Create Pydantic model from parameters
+        args_schema = _create_pydantic_model(schema)
+
+        return DynamicAPIVerveTool(
+            name=api_id,
+            description=description,
+            api_id=api_id,
+            method=method,
+            client=self.client,
+            args_schema=args_schema,
+        )
+
+    def get_tool(self, api_id: str) -> Optional[DynamicAPIVerveTool]:
+        """
+        Get a single tool by API ID.
+
+        Args:
+            api_id: The API identifier (e.g., "emailvalidator")
+
+        Returns:
+            The tool, or None if not found.
+        """
+        schema = self._schemas.get(api_id)
+        if not schema:
+            return None
+        return self._create_tool(schema)
+
+    def list_available_apis(self) -> List[Dict]:
+        """
+        List all available APIs.
+
+        Returns:
+            List of dicts with id, title, description, and category.
+        """
+        return [
+            {
+                "id": schema.get("apiId"),
+                "title": schema.get("title"),
+                "description": schema.get("description"),
+                "category": schema.get("category"),
+            }
+            for schema in self._schemas.values()
+        ]
+
+    def list_categories(self) -> List[str]:
+        """List all available API categories."""
+        return sorted(set(
+            schema.get("category", "Other")
+            for schema in self._schemas.values()
+        ))
+
+    @property
+    def total_apis(self) -> int:
+        """Total number of available APIs."""
+        return self._total_apis

langchain_apiverve-0.1.0/src/langchain_apiverve/tools.py

@@ -0,0 +1,13 @@
+"""
+APIVerve LangChain Tools - Base classes and utilities.
+
+Tools are dynamically generated from API schemas in the toolkit module.
+This module provides the base tool class used by the toolkit.
+"""
+
+# Tools are dynamically created in toolkit.py using DynamicAPIVerveTool
+# See toolkit.py for the implementation
+
+from langchain_apiverve.toolkit import DynamicAPIVerveTool
+
+__all__ = ["DynamicAPIVerveTool"]

langchain_apiverve-0.1.0/src/langchain_apiverve/utils.py

@@ -0,0 +1,26 @@
+"""
+Utility functions for langchain-apiverve.
+"""
+
+import re
+from typing import List
+
+
+def to_snake_case(name: str) -> str:
+    """Convert a string to snake_case."""
+    name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+    name = re.sub('([a-z0-9])([A-Z])', r'\1_\2', name)
+    return name.lower().replace('-', '_').replace(' ', '_')
+
+
+def to_pascal_case(name: str) -> str:
+    """Convert a string to PascalCase."""
+    words = re.split(r'[-_\s]+', name)
+    return ''.join(word.capitalize() for word in words)
+
+
+def truncate_text(text: str, max_length: int = 200, suffix: str = "...") -> str:
+    """Truncate text to a maximum length."""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length - len(suffix)] + suffix