langchain-zerogpu 0.2.1__tar.gz

langchain_zerogpu-0.2.1/.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+
+# Build artifacts
+build/
+dist/
+
+# Virtual environments
+.venv/
+venv/
+
+# Tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# OS
+.DS_Store

langchain_zerogpu-0.2.1/CHANGELOG.md

@@ -0,0 +1,82 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.1] - 2026-06-03
+
+First release published to PyPI. The library is unchanged since 0.2.0 — this
+release establishes the automated release pipeline: tagged versions are built,
+published to PyPI via Trusted Publishing (OIDC), and turned into GitHub
+releases whose notes come straight from this changelog.
+
+### Added
+
+- CI `changelog` job that fails pull requests changing package code without a
+  matching `CHANGELOG.md` update.
+
+### Changed
+
+- The `Release` workflow now creates the GitHub release from the matching
+  `## [X.Y.Z]` section of this changelog (titled `langchain-zerogpu X.Y.Z`,
+  with an install block and the built artifacts attached) instead of
+  auto-generated notes, and publishes to PyPI via Trusted Publishing.
+
+## [0.2.0] - 2026-06-02
+
+### Changed
+
+- All eleven tools now route through the ZeroGPU Responses API. `ZeroGPUChatTool`
+  and `ZeroGPUChatThinkingTool` were migrated off chat completions onto
+  `responses.create_response`, so every tool shares one SDK surface; a system
+  prompt is carried as a system/user message pair.
+- `__version__` is now derived from the installed distribution metadata via
+  `importlib.metadata`, making `pyproject.toml` the single source of truth for
+  the version.
+- Adopted the canonical ZeroGPU product description across the package metadata,
+  README, and docstrings.
+
+### Removed
+
+- `ZeroGPUClient.chat()` / `ZeroGPUClient.achat()` and the chat-completions
+  response handling, superseded by the Responses API path.
+
+### Fixed
+
+- Corrected the summarize model identifier to `llama-3.1-8b-instruct-fast`
+  (previously the hyphenated `llama-3-1-8b-instruct-fast`).
+
+## [0.1.0] - 2026-06-01
+
+### Added
+
+- Initial release of `langchain-zerogpu`.
+- Eleven LangChain `BaseTool` subclasses wrapping ZeroGPU small/nano language model tasks:
+  - `ZeroGPUChatTool` (`LFM2.5-1.2B-Instruct`)
+  - `ZeroGPUChatThinkingTool` (`LFM2.5-1.2B-Thinking`)
+  - `ZeroGPUSummarizeTool` (`llama-3.1-8b-instruct-fast`)
+  - `ZeroGPUClassifyIABTool` (`zlm-v1-iab-classify-edge`)
+  - `ZeroGPUClassifyIABEnrichedTool` (`zlm-v1-iab-classify-edge-enriched`)
+  - `ZeroGPUClassifyZeroShotTool` (`deberta-v3-small`)
+  - `ZeroGPUClassifyStructuredTool` (`gliner2-base-v1`)
+  - `ZeroGPUExtractEntitiesTool` (`gliner2-base-v1`)
+  - `ZeroGPUExtractPIITool` (`gliner-multi-pii-v1`)
+  - `ZeroGPURedactPIITool` (`gliner-multi-pii-v1`)
+  - `ZeroGPUExtractJSONTool` (`gliner2-base-v1`)
+- `ZeroGPUToolkit` bundling all eleven tools behind a single shared client.
+- Credential resolution from constructor arguments or the `ZEROGPU_API_KEY` /
+  `ZEROGPU_PROJECT_ID` environment variables, with the API key stored as a
+  `pydantic.SecretStr`.
+- Synchronous and asynchronous execution for every tool via the official
+  `zerogpu-api` SDK.
+- Clear error messages for authentication (401), access (403), rate-limit
+  (429), server (5xx), and network failures.
+
+[Unreleased]: https://github.com/zerogpu/langchain-zerogpu/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/zerogpu/langchain-zerogpu/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/zerogpu/langchain-zerogpu/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/zerogpu/langchain-zerogpu/releases/tag/v0.1.0

langchain_zerogpu-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZeroGPU
+
+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_zerogpu-0.2.1/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: langchain-zerogpu
+Version: 0.2.1
+Summary: LangChain tools for ZeroGPU: A compute-efficient inference provider for apps and agents — purpose-built small and nano language models on an edge network that run the repeatable tasks frontier models shouldn’t, ~10x faster and 50%+ cheaper. Auto-scaling, with zero GPU infrastructure. Plug in and you’re live.
+Project-URL: Homepage, https://github.com/zerogpu/langchain-zerogpu
+Project-URL: Repository, https://github.com/zerogpu/langchain-zerogpu
+Project-URL: Documentation, https://docs.zerogpu.ai
+Project-URL: Changelog, https://github.com/zerogpu/langchain-zerogpu/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/zerogpu/langchain-zerogpu/issues
+Author-email: ZeroGPU <support@zerogpu.ai>
+License: MIT
+License-File: LICENSE
+Keywords: classification,langchain,llm,ner,nlp,pii,tools,zerogpu
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: <4.0,>=3.10
+Requires-Dist: langchain-core<2.0.0,>=0.3.0
+Requires-Dist: zerogpu-api<0.2.0,>=0.1.3
+Description-Content-Type: text/markdown
+
+# langchain-zerogpu
+
+LangChain tools for [ZeroGPU](https://zerogpu.ai).
+
+ZeroGPU is a compute-efficient inference provider for apps and agents. We run
+purpose-built small and nano language models across an edge network for the
+high-volume tasks you run constantly — classification, extraction, moderation,
+routing, summarization — at ~10x lower latency and 50%+ lower cost than
+frontier-model workflows. Auto-scaling, with zero GPU infrastructure to manage.
+Plug in and you're live.
+
+This package exposes those models as first-class LangChain
+[`BaseTool`](https://python.langchain.com/docs/concepts/tools/) subclasses, so
+any LangChain agent — including `create_agent` and LangGraph graphs — can offload
+these repeatable NLP tasks (classification, summarization, entity / JSON
+extraction, PII redaction, and short chat) to ZeroGPU instead of spending
+frontier-model tokens.
+
+All calls go through the official [`zerogpu-api`](https://pypi.org/project/zerogpu-api/)
+Python SDK.
+
+## Install
+
+```bash
+pip install langchain-zerogpu
+```
+
+## Authenticate
+
+Every request needs a ZeroGPU **API key** (starts with `zgpu-api-`) and a
+**project id**. Provide them via environment variables:
+
+```bash
+export ZEROGPU_API_KEY="zgpu-api-..."
+export ZEROGPU_PROJECT_ID="your-project-id"
+```
+
+…or pass them directly to any tool or the toolkit:
+
+```python
+from langchain_zerogpu import ZeroGPUSummarizeTool
+
+tool = ZeroGPUSummarizeTool(api_key="zgpu-api-...", project_id="your-project-id")
+```
+
+The API key is stored as a `pydantic.SecretStr` and is never logged.
+
+## The tools
+
+| Tool class | ZeroGPU model | Purpose |
+| --- | --- | --- |
+| `ZeroGPUChatTool` | `LFM2.5-1.2B-Instruct` | Short single-turn chat reply |
+| `ZeroGPUChatThinkingTool` | `LFM2.5-1.2B-Thinking` | Chat with a visible reasoning trace |
+| `ZeroGPUSummarizeTool` | `llama-3.1-8b-instruct-fast` | Condense a passage |
+| `ZeroGPUClassifyIABTool` | `zlm-v1-iab-classify-edge` | IAB taxonomy classification |
+| `ZeroGPUClassifyIABEnrichedTool` | `zlm-v1-iab-classify-edge-enriched` | IAB + topics / keywords / intent |
+| `ZeroGPUClassifyZeroShotTool` | `deberta-v3-small` | Zero-shot vs. custom labels |
+| `ZeroGPUClassifyStructuredTool` | `gliner2-base-v1` | Multi-axis schema classification |
+| `ZeroGPUExtractEntitiesTool` | `gliner2-base-v1` | Custom-label NER |
+| `ZeroGPUExtractPIITool` | `gliner-multi-pii-v1` | Extract PII entities (JSON) |
+| `ZeroGPURedactPIITool` | `gliner-multi-pii-v1` | Mask PII inline with `[LABEL]` |
+| `ZeroGPUExtractJSONTool` | `gliner2-base-v1` | Schema-driven JSON extraction |
+
+## Quick start
+
+```python
+from langchain_zerogpu import ZeroGPUClassifyZeroShotTool
+
+tool = ZeroGPUClassifyZeroShotTool()  # reads creds from the environment
+
+print(tool.invoke({
+    "text": "The new GPU smashes every benchmark we threw at it.",
+    "labels": ["tech", "politics", "sports"],
+}))
+```
+
+Tools work asynchronously too:
+
+```python
+result = await tool.ainvoke({"text": "...", "labels": ["a", "b"]})
+```
+
+## Bind the tools to an agent
+
+Use the toolkit to get all eleven tools — wired to a single shared client — and
+bind them to an agent:
+
+```python
+from langchain.agents import create_agent
+from langchain_zerogpu import ZeroGPUToolkit
+
+toolkit = ZeroGPUToolkit()  # reads ZEROGPU_API_KEY / ZEROGPU_PROJECT_ID
+tools = toolkit.get_tools()
+
+agent = create_agent("anthropic:claude-sonnet-4-6", tools=tools)
+
+agent.invoke({
+    "messages": [
+        {"role": "user", "content": "Redact the PII in: 'Call Jane at 555-0100.'"}
+    ]
+})
+```
+
+Or bind a single tool to a chat model directly:
+
+```python
+from langchain.chat_models import init_chat_model
+from langchain_zerogpu import ZeroGPUExtractPIITool
+
+llm = init_chat_model("anthropic:claude-sonnet-4-6")
+llm_with_tools = llm.bind_tools([ZeroGPUExtractPIITool()])
+```
+
+## Errors
+
+Failures surface as clear, typed exceptions instead of raw stack traces:
+
+- `ZeroGPUAuthError` — missing / malformed credentials, `401`, or `403`.
+- `ZeroGPUError` — rate limits (`429`), server errors (`5xx`), and network
+  failures.
+
+## Development
+
+```bash
+make install            # uv sync --all-groups
+make lint               # ruff check + format --check
+make mypy               # mypy (disallow_untyped_defs)
+make test               # unit tests, sockets disabled
+make integration_test   # integration tests (needs real ZeroGPU creds)
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

langchain_zerogpu-0.2.1/README.md

@@ -0,0 +1,134 @@
+# langchain-zerogpu
+
+LangChain tools for [ZeroGPU](https://zerogpu.ai).
+
+ZeroGPU is a compute-efficient inference provider for apps and agents. We run
+purpose-built small and nano language models across an edge network for the
+high-volume tasks you run constantly — classification, extraction, moderation,
+routing, summarization — at ~10x lower latency and 50%+ lower cost than
+frontier-model workflows. Auto-scaling, with zero GPU infrastructure to manage.
+Plug in and you're live.
+
+This package exposes those models as first-class LangChain
+[`BaseTool`](https://python.langchain.com/docs/concepts/tools/) subclasses, so
+any LangChain agent — including `create_agent` and LangGraph graphs — can offload
+these repeatable NLP tasks (classification, summarization, entity / JSON
+extraction, PII redaction, and short chat) to ZeroGPU instead of spending
+frontier-model tokens.
+
+All calls go through the official [`zerogpu-api`](https://pypi.org/project/zerogpu-api/)
+Python SDK.
+
+## Install
+
+```bash
+pip install langchain-zerogpu
+```
+
+## Authenticate
+
+Every request needs a ZeroGPU **API key** (starts with `zgpu-api-`) and a
+**project id**. Provide them via environment variables:
+
+```bash
+export ZEROGPU_API_KEY="zgpu-api-..."
+export ZEROGPU_PROJECT_ID="your-project-id"
+```
+
+…or pass them directly to any tool or the toolkit:
+
+```python
+from langchain_zerogpu import ZeroGPUSummarizeTool
+
+tool = ZeroGPUSummarizeTool(api_key="zgpu-api-...", project_id="your-project-id")
+```
+
+The API key is stored as a `pydantic.SecretStr` and is never logged.
+
+## The tools
+
+| Tool class | ZeroGPU model | Purpose |
+| --- | --- | --- |
+| `ZeroGPUChatTool` | `LFM2.5-1.2B-Instruct` | Short single-turn chat reply |
+| `ZeroGPUChatThinkingTool` | `LFM2.5-1.2B-Thinking` | Chat with a visible reasoning trace |
+| `ZeroGPUSummarizeTool` | `llama-3.1-8b-instruct-fast` | Condense a passage |
+| `ZeroGPUClassifyIABTool` | `zlm-v1-iab-classify-edge` | IAB taxonomy classification |
+| `ZeroGPUClassifyIABEnrichedTool` | `zlm-v1-iab-classify-edge-enriched` | IAB + topics / keywords / intent |
+| `ZeroGPUClassifyZeroShotTool` | `deberta-v3-small` | Zero-shot vs. custom labels |
+| `ZeroGPUClassifyStructuredTool` | `gliner2-base-v1` | Multi-axis schema classification |
+| `ZeroGPUExtractEntitiesTool` | `gliner2-base-v1` | Custom-label NER |
+| `ZeroGPUExtractPIITool` | `gliner-multi-pii-v1` | Extract PII entities (JSON) |
+| `ZeroGPURedactPIITool` | `gliner-multi-pii-v1` | Mask PII inline with `[LABEL]` |
+| `ZeroGPUExtractJSONTool` | `gliner2-base-v1` | Schema-driven JSON extraction |
+
+## Quick start
+
+```python
+from langchain_zerogpu import ZeroGPUClassifyZeroShotTool
+
+tool = ZeroGPUClassifyZeroShotTool()  # reads creds from the environment
+
+print(tool.invoke({
+    "text": "The new GPU smashes every benchmark we threw at it.",
+    "labels": ["tech", "politics", "sports"],
+}))
+```
+
+Tools work asynchronously too:
+
+```python
+result = await tool.ainvoke({"text": "...", "labels": ["a", "b"]})
+```
+
+## Bind the tools to an agent
+
+Use the toolkit to get all eleven tools — wired to a single shared client — and
+bind them to an agent:
+
+```python
+from langchain.agents import create_agent
+from langchain_zerogpu import ZeroGPUToolkit
+
+toolkit = ZeroGPUToolkit()  # reads ZEROGPU_API_KEY / ZEROGPU_PROJECT_ID
+tools = toolkit.get_tools()
+
+agent = create_agent("anthropic:claude-sonnet-4-6", tools=tools)
+
+agent.invoke({
+    "messages": [
+        {"role": "user", "content": "Redact the PII in: 'Call Jane at 555-0100.'"}
+    ]
+})
+```
+
+Or bind a single tool to a chat model directly:
+
+```python
+from langchain.chat_models import init_chat_model
+from langchain_zerogpu import ZeroGPUExtractPIITool
+
+llm = init_chat_model("anthropic:claude-sonnet-4-6")
+llm_with_tools = llm.bind_tools([ZeroGPUExtractPIITool()])
+```
+
+## Errors
+
+Failures surface as clear, typed exceptions instead of raw stack traces:
+
+- `ZeroGPUAuthError` — missing / malformed credentials, `401`, or `403`.
+- `ZeroGPUError` — rate limits (`429`), server errors (`5xx`), and network
+  failures.
+
+## Development
+
+```bash
+make install            # uv sync --all-groups
+make lint               # ruff check + format --check
+make mypy               # mypy (disallow_untyped_defs)
+make test               # unit tests, sockets disabled
+make integration_test   # integration tests (needs real ZeroGPU creds)
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

langchain_zerogpu-0.2.1/langchain_zerogpu/__init__.py

@@ -0,0 +1,59 @@
+"""LangChain tools for ZeroGPU.
+
+ZeroGPU is a compute-efficient inference provider for apps and agents. It runs
+purpose-built small and nano language models across an edge network for the
+high-volume tasks you run constantly -- classification, extraction, moderation,
+routing, summarization -- at ~10x lower latency and 50%+ lower cost than
+frontier-model workflows.
+
+This package exposes the eleven ZeroGPU task models -- chat, summarization,
+classification, entity / JSON extraction, and PII extraction / redaction -- as
+first-class LangChain :class:`~langchain_core.tools.BaseTool` subclasses, plus a
+:class:`ZeroGPUToolkit` that bundles them behind a single shared client.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from langchain_zerogpu._client import ZeroGPUAuthError, ZeroGPUClient, ZeroGPUError
+from langchain_zerogpu.toolkit import ZeroGPUToolkit
+from langchain_zerogpu.tools import (
+    ZeroGPUChatThinkingTool,
+    ZeroGPUChatTool,
+    ZeroGPUClassifyIABEnrichedTool,
+    ZeroGPUClassifyIABTool,
+    ZeroGPUClassifyStructuredTool,
+    ZeroGPUClassifyZeroShotTool,
+    ZeroGPUExtractEntitiesTool,
+    ZeroGPUExtractJSONTool,
+    ZeroGPUExtractPIITool,
+    ZeroGPURedactPIITool,
+    ZeroGPUSummarizeTool,
+)
+
+try:
+    # Single source of truth: the version declared in pyproject.toml and
+    # baked into the installed distribution's metadata. Avoids drift between
+    # this module and pyproject.
+    __version__ = version("langchain-zerogpu")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0"
+
+__all__ = [
+    "ZeroGPUChatTool",
+    "ZeroGPUChatThinkingTool",
+    "ZeroGPUSummarizeTool",
+    "ZeroGPUClassifyIABTool",
+    "ZeroGPUClassifyIABEnrichedTool",
+    "ZeroGPUClassifyZeroShotTool",
+    "ZeroGPUClassifyStructuredTool",
+    "ZeroGPUExtractEntitiesTool",
+    "ZeroGPUExtractPIITool",
+    "ZeroGPURedactPIITool",
+    "ZeroGPUExtractJSONTool",
+    "ZeroGPUToolkit",
+    "ZeroGPUClient",
+    "ZeroGPUAuthError",
+    "ZeroGPUError",
+]