langchain-openapi-tools 1.0.2__tar.gz → 1.1.3__tar.gz

{langchain_openapi_tools-1.0.2 → langchain_openapi_tools-1.1.3}/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.0.2] - 2026-08-01
+
+### Fixed
+- **Base URL Generation**: Fixed Swagger 2.0 base URL generation (e.g. Crossref host/basePath/schemes resolution) to prevent relative URL execution errors.
+- **URL Resolution**: Updated `RequestBuilder` to use `urllib.parse.urljoin` for safe URL concatenation.
+
+### Added
+- **Package Naming Clarification**: Clarified PyPI package name (`langchain-openapi-tools`) vs import module name (`langchain_openapi`) across documentation.
+- **Prompt Optimization & Config**: Introduced `OpenAPIToolkitConfig` for user-controlled description modes (`full`, `compact`, `minimal`) and description prompt compression (`compress_descriptions=True`).
+- **Tool Description Customization**: Added `tool_description_overrides` dict and custom `description_builder` callback functions.
+- **Operation & Tag Filtering**: Added tag filtering (`include_tags`, `exclude_tags`) and operation filtering (`include_operations`, `exclude_operations`) at initial toolkit construction level.
+
+---
+
 ## [1.0.0] - 2026-08-01
 
 ### Added

{langchain_openapi_tools-1.0.2 → langchain_openapi_tools-1.1.3}/Makefile

@@ -10,7 +10,7 @@ lint:
 	uv run ruff check .
 
 typecheck:
-	uv run mypy langchain_openapi tests examples
+	uv run mypy langchain_openapi_tools langchain_openapi tests examples
 
 format:
 	uv run ruff format .

{langchain_openapi_tools-1.0.2 → langchain_openapi_tools-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-openapi-tools
-Version: 1.0.2
+Version: 1.1.3
 Summary: Convert OpenAPI specifications into native, production-grade LangChain tools.
 Project-URL: Homepage, https://github.com/abhaywani114/langchain-openapi
 Project-URL: Documentation, https://abhaywani114.github.io/langchain-openapi/
@@ -46,7 +46,7 @@ Description-Content-Type: text/markdown
 </p>
 
 <p align="center">
-  <em>Convert OpenAPI v3.0 & v3.1 specifications into native, production-grade LangChain tools.</em>
+  <em>Convert OpenAPI v3.0 & v3.1 and Swagger 2.0 specifications into native, production-grade LangChain tools.</em>
 </p>
 
 <p align="center">
@@ -61,15 +61,45 @@ Description-Content-Type: text/markdown
 
 ---
 
-`langchain_openapi` is a modern Python library designed to seamlessly convert OpenAPI v3.0 and v3.1 specifications into native, type-safe [LangChain](https://github.com/langchain-ai/langchain) tools for AI agents and LLM applications.
+`langchain_openapi` is a modern Python library designed to seamlessly convert OpenAPI v3.0, v3.1, and Swagger 2.0 specifications into native, type-safe [LangChain](https://github.com/langchain-ai/langchain) tools for AI agents and LLM applications.
 
-No python code generation is required—tools are generated dynamically at runtime with strict Pydantic input schemas and production-ready middleware.
+No python code generation is required—tools are generated dynamically at runtime with strict Pydantic input schemas, prompt optimization options, and production-ready middleware.
+
+---
+
+## Installation & Importing
+
+Install the PyPI package:
+
+```bash
+pip install langchain-openapi-tools
+# or using uv
+uv add langchain-openapi-tools
+```
+
+Import in Python:
+
+```python
+from langchain_openapi_tools import OpenAPIToolkit, OpenAPIToolkitConfig
+```
+
+### Migration Note
+
+```python
+# Old (deprecated, but still works for backward compatibility):
+from langchain_openapi import OpenAPIToolkit
+
+# New (recommended):
+from langchain_openapi_tools import OpenAPIToolkit
+```
 
 ---
 
 ## Features
 
 - ⚡ **Zero-Code Tool Generation**: Runtime conversion of OpenAPI specs (YAML/JSON) into LangChain `StructuredTool`s.
+- 🚀 **Swagger 2.0 & OpenAPI 3.x**: Native normalization of legacy Swagger 2.0 and modern OpenAPI 3.0/3.1 specs.
+- 🗜️ **Prompt Optimization & Filtering**: Description modes (`full`, `compact`, `minimal`), description compression, overrides, callbacks, and operation/tag filtering to drastically reduce context window usage.
 - 🔒 **Pluggable Authentication**: Built-in support for Bearer Tokens, API Key Headers, Query Parameters, Basic Auth, and custom request providers.
 - 🛡️ **Production Middleware**: Composable middleware architecture for Retries (exponential backoff), Rate Limiting (token-bucket), Caching (TTL), Pagination aggregation, and Sanitized Logging.
 - 🎯 **Type-Safe Validation**: Dynamically generated Pydantic input schemas ensure LLM arguments adhere strictly to specification types before network transport.
@@ -85,47 +115,10 @@ No python code generation is required—tools are generated dynamically at runti
 
 ---
 
-## Architecture Pipeline
-
-```text
-          Swagger 2.0 / OpenAPI 3.x
-                     │
-                     ▼
-            Swagger Normalizer
-                     │
-                     ▼
-          Normalized OpenAPI Model
-                     │
-                     ▼
-              Existing Parser
-                     │
-                     ▼
-           Internal Operation Models
-                     │
-                     ▼
-            Schema Converter
-                     │
-                     ▼
-              HTTP Executor
-                     │
-                     ▼
-          LangChain StructuredTools
-```
-
 ## Quick Start
 
-### Installation
-
-```bash
-uv add langchain-openapi-tools
-# or
-pip install langchain-openapi-tools
-```
-
-### Basic Usage
-
 ```python
-from langchain_openapi import OpenAPIToolkit
+from langchain_openapi_tools import OpenAPIToolkit
 
 # Load spec from remote URL or local file
 toolkit = OpenAPIToolkit.from_url("https://api.crossref.org/swagger-docs")
@@ -142,12 +135,12 @@ for tool in tools[:3]:
 
 ```python
 import asyncio
-from langchain_openapi import OpenAPIToolkit
+from langchain_openapi_tools import OpenAPIToolkit
 
 
 async def main():
     toolkit = OpenAPIToolkit.from_url("https://api.crossref.org/swagger-docs")
-    search_tool = toolkit.get_tool("search_works")
+    search_tool = toolkit.get_tool("get_works")
 
     if search_tool:
         result = await search_tool.ainvoke({"query": "LangGraph"})
@@ -160,147 +153,106 @@ if __name__ == "__main__":
 
 ---
 
-## Architecture
+## Prompt Optimization & Tool Customization
 
-```text
-OpenAPI Specification (JSON / YAML)
-             │
-             ▼
-      OpenAPILoader
-             │
-             ▼
-       OpenAPIParser ───► ReferenceResolver ($ref)
-             │
-             ▼
-     SchemaConverter ───► Dynamic Pydantic Input Models
-             │
-             ▼
-   LangChainToolFactory ───► LangChain StructuredTool
-             │
-             ▼
-     AsyncHTTPExecutor
-             │
-             ▼
-    Middleware Pipeline (Retry, RateLimit, Cache, Pagination, Logging)
-             │
-             ▼
-    Request Providers (Authentication & Custom Headers)
-             │
-             ▼
-        httpx.AsyncClient (HTTP Target API)
-```
-
----
-
-## Authentication Methods
+Large OpenAPI specifications can generate extensive tool descriptions that exceed model context windows. `langchain_openapi_tools` provides full control over description generation and context footprint.
 
-`langchain_openapi` supports pluggable authentication via `RequestProvider` classes:
+### Configuration Object (`OpenAPIToolkitConfig`)
 
 ```python
-from langchain_openapi import (
-    APIKeyHeaderProvider,
-    BasicAuthProvider,
-    BearerAuthProvider,
-    CompositeProvider,
-    OpenAPIToolkit,
+from langchain_openapi_tools import OpenAPIToolkit, OpenAPIToolkitConfig
+
+config = OpenAPIToolkitConfig(
+    description_mode="compact",
+    compress_descriptions=True,
+    include_tags=["Works"],
+    tool_description_overrides={
+        "get_works": "Search scholarly papers registered with Crossref."
+    },
 )
 
-# 1. Bearer Token Auth
-toolkit_bearer = OpenAPIToolkit.from_url(
-    "https://api.github.com/openapi",
-    provider=BearerAuthProvider(token="secret_token"),
+toolkit = OpenAPIToolkit.from_url(
+    "https://api.crossref.org/swagger-docs", config=config
 )
+```
 
-# 2. API Key Header Auth
-toolkit_apikey = OpenAPIToolkit.from_url(
-    "https://api.example.com/spec.json",
-    provider=APIKeyHeaderProvider(key="secret_key", header="X-API-Key"),
-)
+### Description Modes (`description_mode`)
 
-# 3. Composite Provider (Multiple authentication schemes)
-composite = CompositeProvider(
-    [
-        BearerAuthProvider(token="secret_jwt"),
-        APIKeyHeaderProvider(key="secret_key", header="X-API-Key"),
-    ]
-)
+- `full` *(default)*: Complete summary, description, HTTP method, path, and schema parameter details.
+- `compact`: Summary and short parameter list without response schemas or redundant examples.
+- `minimal`: A single-sentence summary ideal for large specifications with dozens of tools.
 
-toolkit_composite = OpenAPIToolkit.from_url(
-    "https://api.example.com/spec.json",
-    provider=composite,
-)
+```python
+toolkit = OpenAPIToolkit.from_url(url, description_mode="minimal")
 ```
 
----
+### Description Compression (`compress_descriptions=True`)
 
-## Production Middleware & Resilience
-
-Intercept requests and responses to apply cross-cutting resilience concerns:
+Removes duplicate text, redundant whitespace, and empty sections without altering tool semantics:
 
 ```python
-from langchain_openapi import (
-    CacheMiddleware,
-    LoggingMiddleware,
-    OpenAPIToolkit,
-    PaginationMiddleware,
-    RateLimitMiddleware,
-    RetryMiddleware,
-)
-
-toolkit = OpenAPIToolkit.from_url(
-    "https://api.example.com/openapi.json",
-    middleware=[
-        LoggingMiddleware(),
-        RetryMiddleware(retries=3, backoff="exponential"),
-        RateLimitMiddleware(requests_per_second=10.0),
-        CacheMiddleware(ttl=300.0),
-        PaginationMiddleware(max_pages=10),
-    ],
-)
+toolkit = OpenAPIToolkit.from_url(url, compress_descriptions=True)
 ```
 
----
-
-## Example Applications
+### Custom Overrides & Callbacks
 
-Runnable example projects are located in `examples/`:
+Override descriptions for specific tools:
 
-- 📚 [`examples/crossref`](examples/crossref/): Academic works search via Crossref API.
-- 🐙 [`examples/github`](examples/github/): Repository search via GitHub REST API with Bearer Token.
-- 🐶 [`examples/petstore`](examples/petstore/): Pet store management using Swagger Petstore.
-- 📝 [`examples/jsonplaceholder`](examples/jsonplaceholder/): REST resource querying with caching.
+```python
+toolkit = OpenAPIToolkit.from_url(
+    url, tool_description_overrides={"get_works": "Search scholarly papers."}
+)
+```
 
----
+Or pass a custom builder callback:
 
-## Roadmap
+```python
+def my_builder(operation):
+    return f"Execute {operation.name} on path {operation.path}."
 
-- ✅ **Milestone 1**: Project Foundation & Tooling
-- ✅ **Milestone 2**: OpenAPI Specification Loader
-- ✅ **Milestone 3**: OpenAPI Parser & Data Models
-- ✅ **Milestone 4**: Dynamic Pydantic Schema Converter
-- ✅ **Milestone 5**: Async HTTP Executor Engine
-- ✅ **Milestone 6**: LangChain Tool Factory & Toolkit
-- ✅ **Milestone 7**: Authentication & Request Providers
-- ✅ **Milestone 8**: Production Middleware & Resilience Pipeline
-- ✅ **Milestone 9**: Open Source Readiness & Documentation
-- ⏳ **Milestone 10**: v1.0 Release Candidate & PyPI Publish
 
----
+toolkit = OpenAPIToolkit.from_url(url, description_builder=my_builder)
+```
 
-## Development & Contributing
+### Operation Filtering
 
-Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on code style, testing, and pull request procedures.
+Filter tools before they are created to reduce context window overhead:
 
-```bash
-# Sync virtual environment
-uv sync --extra dev
+```python
+# Filter by Tags
+toolkit = OpenAPIToolkit.from_url(url, include_tags=["Works"], exclude_tags=["Admin"])
 
-# Run all checks (format, lint, mypy, pytest, docs build, benchmark)
-make all
+# Filter by Operations
+toolkit = OpenAPIToolkit.from_url(
+    url, include_operations=["get_works"], exclude_operations=["delete_work"]
+)
 ```
 
 ---
 
-## License
+## Architecture Pipeline
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+```text
+          Swagger 2.0 / OpenAPI 3.x
+                     │
+                     ▼
+            Swagger Normalizer
+                     │
+                     ▼
+          Normalized OpenAPI Model
+                     │
+                     ▼
+              Existing Parser
+                     │
+                     ▼
+           Internal Operation Models
+                     │
+                     ▼
+            Schema Converter
+                     │
+                     ▼
+              HTTP Executor
+                     │
+                     ▼
+          LangChain StructuredTools
+```

langchain_openapi_tools-1.1.3/README.md

@@ -0,0 +1,218 @@
+# langchain-openapi
+
+<p align="center">
+  <!-- Logo Placeholder -->
+  <img src="docs/assets/logo.png" alt="langchain-openapi logo" width="200" onerror="this.style.display='none'"/>
+</p>
+
+<p align="center">
+  <em>Convert OpenAPI v3.0 & v3.1 and Swagger 2.0 specifications into native, production-grade LangChain tools.</em>
+</p>
+
+<p align="center">
+  <a href="https://github.com/abhaywani114/langchain-openapi/actions/workflows/ci.yml"><img src="https://github.com/abhaywani114/langchain-openapi/actions/workflows/ci.yml/badge.svg" alt="CI Status"/></a>
+  <a href="https://pypi.org/project/langchain-openapi-tools/"><img src="https://img.shields.io/pypi/v/langchain-openapi-tools.svg" alt="PyPI Version"/></a>
+  <a href="https://abhaywani114.github.io/langchain-openapi/"><img src="https://img.shields.io/badge/docs-mkdocs-blue.svg" alt="Documentation"/></a>
+  <a href="https://python.org"><img src="https://img.shields.io/badge/python-3.11%2B-blue.svg" alt="Python 3.11+"/></a>
+  <a href="https://github.com/astral-sh/ruff"><img src="https://img.shields.io/badge/code%20style-ruff-000000.svg" alt="Code Style: Ruff"/></a>
+  <a href="http://mypy-lang.org/"><img src="https://img.shields.io/badge/mypy-checked-blue.svg" alt="Checked with MyPy"/></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License: MIT"/></a>
+</p>
+
+---
+
+`langchain_openapi` is a modern Python library designed to seamlessly convert OpenAPI v3.0, v3.1, and Swagger 2.0 specifications into native, type-safe [LangChain](https://github.com/langchain-ai/langchain) tools for AI agents and LLM applications.
+
+No python code generation is required—tools are generated dynamically at runtime with strict Pydantic input schemas, prompt optimization options, and production-ready middleware.
+
+---
+
+## Installation & Importing
+
+Install the PyPI package:
+
+```bash
+pip install langchain-openapi-tools
+# or using uv
+uv add langchain-openapi-tools
+```
+
+Import in Python:
+
+```python
+from langchain_openapi_tools import OpenAPIToolkit, OpenAPIToolkitConfig
+```
+
+### Migration Note
+
+```python
+# Old (deprecated, but still works for backward compatibility):
+from langchain_openapi import OpenAPIToolkit
+
+# New (recommended):
+from langchain_openapi_tools import OpenAPIToolkit
+```
+
+---
+
+## Features
+
+- ⚡ **Zero-Code Tool Generation**: Runtime conversion of OpenAPI specs (YAML/JSON) into LangChain `StructuredTool`s.
+- 🚀 **Swagger 2.0 & OpenAPI 3.x**: Native normalization of legacy Swagger 2.0 and modern OpenAPI 3.0/3.1 specs.
+- 🗜️ **Prompt Optimization & Filtering**: Description modes (`full`, `compact`, `minimal`), description compression, overrides, callbacks, and operation/tag filtering to drastically reduce context window usage.
+- 🔒 **Pluggable Authentication**: Built-in support for Bearer Tokens, API Key Headers, Query Parameters, Basic Auth, and custom request providers.
+- 🛡️ **Production Middleware**: Composable middleware architecture for Retries (exponential backoff), Rate Limiting (token-bucket), Caching (TTL), Pagination aggregation, and Sanitized Logging.
+- 🎯 **Type-Safe Validation**: Dynamically generated Pydantic input schemas ensure LLM arguments adhere strictly to specification types before network transport.
+- 🌐 **Async Engine**: Non-blocking asynchronous network transport powered by `httpx.AsyncClient`.
+
+---
+
+## Supported Specifications
+
+- ✅ **Swagger 2.0** (Automatically normalized to OpenAPI 3.0)
+- ✅ **OpenAPI 3.0.x** (JSON and YAML)
+- ✅ **OpenAPI 3.1.x** (JSON and YAML)
+
+---
+
+## Quick Start
+
+```python
+from langchain_openapi_tools import OpenAPIToolkit
+
+# Load spec from remote URL or local file
+toolkit = OpenAPIToolkit.from_url("https://api.crossref.org/swagger-docs")
+
+# Extract generated tools
+tools = toolkit.get_tools()
+
+print(f"Generated {len(tools)} tools:")
+for tool in tools[:3]:
+    print(f"- {tool.name}: {tool.description}")
+```
+
+### Agent Integration
+
+```python
+import asyncio
+from langchain_openapi_tools import OpenAPIToolkit
+
+
+async def main():
+    toolkit = OpenAPIToolkit.from_url("https://api.crossref.org/swagger-docs")
+    search_tool = toolkit.get_tool("get_works")
+
+    if search_tool:
+        result = await search_tool.ainvoke({"query": "LangGraph"})
+        print("Search Result:", result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## Prompt Optimization & Tool Customization
+
+Large OpenAPI specifications can generate extensive tool descriptions that exceed model context windows. `langchain_openapi_tools` provides full control over description generation and context footprint.
+
+### Configuration Object (`OpenAPIToolkitConfig`)
+
+```python
+from langchain_openapi_tools import OpenAPIToolkit, OpenAPIToolkitConfig
+
+config = OpenAPIToolkitConfig(
+    description_mode="compact",
+    compress_descriptions=True,
+    include_tags=["Works"],
+    tool_description_overrides={
+        "get_works": "Search scholarly papers registered with Crossref."
+    },
+)
+
+toolkit = OpenAPIToolkit.from_url(
+    "https://api.crossref.org/swagger-docs", config=config
+)
+```
+
+### Description Modes (`description_mode`)
+
+- `full` *(default)*: Complete summary, description, HTTP method, path, and schema parameter details.
+- `compact`: Summary and short parameter list without response schemas or redundant examples.
+- `minimal`: A single-sentence summary ideal for large specifications with dozens of tools.
+
+```python
+toolkit = OpenAPIToolkit.from_url(url, description_mode="minimal")
+```
+
+### Description Compression (`compress_descriptions=True`)
+
+Removes duplicate text, redundant whitespace, and empty sections without altering tool semantics:
+
+```python
+toolkit = OpenAPIToolkit.from_url(url, compress_descriptions=True)
+```
+
+### Custom Overrides & Callbacks
+
+Override descriptions for specific tools:
+
+```python
+toolkit = OpenAPIToolkit.from_url(
+    url, tool_description_overrides={"get_works": "Search scholarly papers."}
+)
+```
+
+Or pass a custom builder callback:
+
+```python
+def my_builder(operation):
+    return f"Execute {operation.name} on path {operation.path}."
+
+
+toolkit = OpenAPIToolkit.from_url(url, description_builder=my_builder)
+```
+
+### Operation Filtering
+
+Filter tools before they are created to reduce context window overhead:
+
+```python
+# Filter by Tags
+toolkit = OpenAPIToolkit.from_url(url, include_tags=["Works"], exclude_tags=["Admin"])
+
+# Filter by Operations
+toolkit = OpenAPIToolkit.from_url(
+    url, include_operations=["get_works"], exclude_operations=["delete_work"]
+)
+```
+
+---
+
+## Architecture Pipeline
+
+```text
+          Swagger 2.0 / OpenAPI 3.x
+                     │
+                     ▼
+            Swagger Normalizer
+                     │
+                     ▼
+          Normalized OpenAPI Model
+                     │
+                     ▼
+              Existing Parser
+                     │
+                     ▼
+           Internal Operation Models
+                     │
+                     ▼
+            Schema Converter
+                     │
+                     ▼
+              HTTP Executor
+                     │
+                     ▼
+          LangChain StructuredTools
+```

langchain_openapi_tools-1.1.3/docs/api/executor.md

@@ -0,0 +1,5 @@
+# AsyncHTTPExecutor API Reference
+
+::: langchain_openapi_tools.executor.AsyncHTTPExecutor
+::: langchain_openapi_tools.executor.RequestBuilder
+::: langchain_openapi_tools.executor.ResponseParser

langchain_openapi_tools-1.1.3/docs/api/loader.md

@@ -0,0 +1,3 @@
+# OpenAPILoader API Reference
+
+::: langchain_openapi_tools.loader.OpenAPILoader

langchain_openapi_tools-1.1.3/docs/api/middleware.md

@@ -0,0 +1,8 @@
+# Middleware API Reference
+
+::: langchain_openapi_tools.middleware.MiddlewarePipeline
+::: langchain_openapi_tools.middleware.RetryMiddleware
+::: langchain_openapi_tools.middleware.RateLimitMiddleware
+::: langchain_openapi_tools.middleware.CacheMiddleware
+::: langchain_openapi_tools.middleware.PaginationMiddleware
+::: langchain_openapi_tools.middleware.LoggingMiddleware

langchain_openapi_tools-1.1.3/docs/api/parser.md

@@ -0,0 +1,4 @@
+# OpenAPIParser API Reference
+
+::: langchain_openapi_tools.parser.OpenAPIParser
+::: langchain_openapi_tools.parser.ReferenceResolver

langchain_openapi_tools-1.1.3/docs/api/toolkit.md

@@ -0,0 +1,4 @@
+# OpenAPIToolkit API Reference
+
+::: langchain_openapi_tools.toolkit.OpenAPIToolkit
+::: langchain_openapi_tools.toolkit.LangChainToolFactory

{langchain_openapi_tools-1.0.2 → langchain_openapi_tools-1.1.3}/docs/authentication.md

@@ -11,7 +11,7 @@
 Injects an `Authorization: Bearer <TOKEN>` header.
 
 ```python
-from langchain_openapi import BearerAuthProvider, OpenAPIToolkit
+from langchain_openapi_tools import BearerAuthProvider, OpenAPIToolkit
 
 toolkit = OpenAPIToolkit.from_url(
     "https://api.github.com/openapi",
@@ -24,7 +24,7 @@ toolkit = OpenAPIToolkit.from_url(
 Injects an API key in a designated request header.
 
 ```python
-from langchain_openapi import APIKeyHeaderProvider, OpenAPIToolkit
+from langchain_openapi_tools import APIKeyHeaderProvider, OpenAPIToolkit
 
 toolkit = OpenAPIToolkit.from_url(
     "https://api.example.com/spec.json",
@@ -37,7 +37,7 @@ toolkit = OpenAPIToolkit.from_url(
 Appends an API key as a query parameter.
 
 ```python
-from langchain_openapi import APIKeyQueryProvider, OpenAPIToolkit
+from langchain_openapi_tools import APIKeyQueryProvider, OpenAPIToolkit
 
 toolkit = OpenAPIToolkit.from_url(
     "https://api.example.com/spec.json",
@@ -50,7 +50,7 @@ toolkit = OpenAPIToolkit.from_url(
 Injects HTTP Basic Authentication credentials.
 
 ```python
-from langchain_openapi import BasicAuthProvider, OpenAPIToolkit
+from langchain_openapi_tools import BasicAuthProvider, OpenAPIToolkit
 
 toolkit = OpenAPIToolkit.from_url(
     "https://api.example.com/spec.json",
@@ -65,7 +65,7 @@ toolkit = OpenAPIToolkit.from_url(
 Chain multiple request providers sequentially using `CompositeProvider`:
 
 ```python
-from langchain_openapi import (
+from langchain_openapi_tools import (
     BearerAuthProvider,
     CompositeProvider,
     CookiesProvider,

{langchain_openapi_tools-1.0.2 → langchain_openapi_tools-1.1.3}/docs/examples/crossref.md

@@ -8,7 +8,7 @@ This example demonstrates using `langchain-openapi` with the public [Crossref RE
 
 ```python
 import asyncio
-from langchain_openapi import OpenAPIToolkit, RetryMiddleware, LoggingMiddleware
+from langchain_openapi_tools import OpenAPIToolkit, RetryMiddleware, LoggingMiddleware
 
 
 async def main():