langchain-tensorust 0.1.0__tar.gz

langchain_tensorust-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

langchain_tensorust-0.1.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0 (2026-11-15)
+
+First release.
+
+- Seven LangChain tools over the Tensorust Ontology, each with a typed input schema and sync and
+  async paths: `TensorustLookupOrganization`, `TensorustWhoOwnsHome`, `TensorustLenderMarks`,
+  `TensorustContractorCredit`, `TensorustSanctionsScreen`, `TensorustIDROffer`,
+  `TensorustDatasetSearch`.
+- `TensorustToolkit` returns them sharing one client; `include=` picks a subset.
+  `aget_mcp_tools()` loads every tool on the Tensorust MCP server through
+  `langchain-mcp-adapters` (extra `mcp`).
+- Keyless by default (free previews). `TENSORUST_API_KEY` sends a bearer token and asks for full
+  records. The endpoint must be https (http only for localhost).
+- Errors (bad input, 401, 402, 429, tool errors) come back to the agent as text instead of
+  raising.
+- Passes the LangChain standard tool tests (`langchain-tests`) for every tool.

langchain_tensorust-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Busel
+
+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_tensorust-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.5
+Name: langchain-tensorust
+Version: 0.1.0
+Summary: LangChain tools for the Tensorust Ontology: who owns or controls US companies and homes, private credit loan marks, contractor credit, OFAC and banned-vendor screens, from public records.
+Project-URL: Homepage, https://github.com/Mattbusel/langchain-tensorust
+Project-URL: Documentation, https://github.com/Mattbusel/langchain-tensorust/blob/main/docs/index.md
+Project-URL: Changelog, https://github.com/Mattbusel/langchain-tensorust/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Mattbusel/langchain-tensorust/issues
+Author: Matthew Busel
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,kyb,langchain,mcp,ofac,ownership,private-credit,sanctions,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: langchain-core<2,>=1.0
+Requires-Dist: pydantic<3,>=2.7
+Provides-Extra: mcp
+Requires-Dist: langchain-mcp-adapters>=0.1; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# langchain-tensorust
+
+LangChain tools for the [Tensorust Ontology](https://tensorust.com): ownership, private
+credit and compliance lookups built from US public records (SEC subsidiary lists and BDC
+schedules of investments, state business registries, county property rolls, FCC, federal
+awards, OFAC, the CMS Federal IDR file).
+
+```bash
+pip install -U langchain-tensorust
+```
+
+```python
+from langchain.agents import create_agent
+from langchain_tensorust import TensorustToolkit
+
+agent = create_agent("anthropic:claude-sonnet-4-6", tools=TensorustToolkit().get_tools())
+agent.invoke({"messages": [("user", "Who controls Invitation Homes, and what do lenders mark Pluralsight's loan at?")]})
+```
+
+| Tool | Answers |
+|---|---|
+| `TensorustLookupOrganization` | Who owns or controls a company: parent, control group, subsidiaries, homes, FCC licenses, awards, rules that apply |
+| `TensorustWhoOwnsHome` | Owner of record of a US single-family home and its parent control group |
+| `TensorustLenderMarks` | What each BDC lender marks a private company's first-lien loan at, and the spread |
+| `TensorustContractorCredit` | Credit health of a federal contractor: obligations, lender marks, headcount trend |
+| `TensorustSanctionsScreen` | OFAC plus DoD 1260H, Section 889, FCC Covered List, UFLPA and BIOSECURE screen |
+| `TensorustIDROffer` | No Surprises Act arbitration outcomes for a CPT code, payer and state |
+| `TensorustDatasetSearch` | Search 145 entity-level datasets built from public records |
+
+No key is needed: every tool answers with a free preview. Set `TENSORUST_API_KEY` to a
+`tdk_...` key for full records. `await TensorustToolkit().aget_mcp_tools()` (with the `mcp`
+extra) loads every tool on the Tensorust MCP server, about 40.
+
+Docs: https://github.com/Mattbusel/langchain-tensorust/blob/main/docs/index.md

langchain_tensorust-0.1.0/docs/index.md

@@ -0,0 +1,113 @@
+# Tensorust tools for LangChain
+
+`langchain-tensorust` gives LangChain agents ownership, private credit and compliance lookups
+built from US public records: SEC subsidiary lists and BDC schedules of investments, state
+business registries, county property rolls, FCC licensing, federal awards, OFAC and the CMS
+Federal IDR public use file. The data comes from the [Tensorust Ontology](https://tensorust.com).
+
+## Overview
+
+| Class | Package | Serializable | JS support | Version |
+|---|---|---|---|---|
+| `TensorustToolkit` | `langchain-tensorust` | no | no | 0.1.0 |
+
+### Tools
+
+| Tool | Remote tool | What it answers |
+|---|---|---|
+| `TensorustLookupOrganization` | `lookup_organization` | Who owns or controls a company: parent, control group, subsidiaries, homes, FCC licenses, federal awards, and the federal rules that apply to it |
+| `TensorustWhoOwnsHome` | `who_owns_home` | Owner of record of a US single-family home and its parent control group (17 large counties) |
+| `TensorustLenderMarks` | `lender_marks` | What each BDC lender marks a private company's first-lien loan at in its latest 10-Q, and the spread between lenders |
+| `TensorustContractorCredit` | `contractor_credit` | Credit health of a federal contractor: obligations by agency, lender marks and their trend, headcount |
+| `TensorustSanctionsScreen` | `query_ontology` + `exposure_screen_purchases` | OFAC match plus DoD 1260H, Section 889, FCC Covered List, UFLPA and BIOSECURE screen, with the rule and citation |
+| `TensorustIDROffer` | `idr_offer` | No Surprises Act arbitration outcomes for a CPT/HCPCS code, payer and state |
+| `TensorustDatasetSearch` | `list_datasets` | Search 145 entity-level datasets (money owed, at risk, unclaimed, about to expire) |
+
+Every tool has a typed input schema and both sync (`invoke`) and async (`ainvoke`) paths.
+
+## Setup
+
+```bash
+pip install -U langchain-tensorust
+# every tool on the Tensorust MCP server, through langchain-mcp-adapters:
+pip install -U "langchain-tensorust[mcp]"
+```
+
+### Credentials
+
+None needed to start. Without a key every tool returns a free preview (counts, the top
+matches, the headline numbers). With a Tensorust key the tools ask for the full record:
+
+```bash
+export TENSORUST_API_KEY="tdk_..."
+```
+
+or pass it in code: `TensorustToolkit(api_wrapper=TensorustAPIWrapper(api_key="tdk_..."))`.
+Keys: https://tensorust.com. `TENSORUST_API_URL` overrides the endpoint (it must be https;
+plain http is allowed only for localhost).
+
+## Instantiation
+
+```python
+from langchain_tensorust import TensorustToolkit
+
+toolkit = TensorustToolkit()
+tools = toolkit.get_tools()
+
+# only some of them
+toolkit = TensorustToolkit(include=["tensorust_lender_marks", "tensorust_sanctions_screen"])
+```
+
+## Invocation
+
+```python
+from langchain_tensorust import TensorustLenderMarks, TensorustSanctionsScreen
+
+TensorustLenderMarks().invoke({"company": "Pluralsight"})
+# {"company": "Pluralsight LLC", "as_of": "2026-06-30", "lowest_mark": 0.808, "lowest_manager": "Blackrock", ...}
+
+TensorustSanctionsScreen().invoke({"name": "Hikvision"})
+# {"sanctions": {"total": 1, ...}, "restricted_vendor_lists": {"by_vendor": {"hikvision": {"lists": ["1260H", "FCC_COVERED", "SEC889"]}}, "flags": [...]}}
+```
+
+Tools return JSON strings. Errors (empty input, 401 bad key, 402 paid call, 429 rate limit, no
+match) come back to the model as text, so the agent can correct itself instead of crashing.
+
+## Use within an agent
+
+```python
+from langchain.agents import create_agent
+from langchain_tensorust import TensorustToolkit
+
+agent = create_agent(
+    "anthropic:claude-sonnet-4-6",
+    tools=TensorustToolkit().get_tools(),
+    system_prompt="You are a counterparty analyst. Cite the numbers the tools return.",
+)
+agent.invoke({"messages": [("user", "Run a counterparty check on Peraton.")]})
+```
+
+See [`examples/kyb_agent.py`](../examples/kyb_agent.py).
+
+## Every tool on the MCP server
+
+The Tensorust endpoint is also an MCP server with about 40 tools (FCC Upper C-band
+clearinghouse checks, E-Rate deadlines, the ROAD Act investor screen, research-security
+exposure by institution, small-business set-aside performance, aircraft owners and more).
+`aget_mcp_tools()` loads all of them through `langchain-mcp-adapters`, with your key attached:
+
+```python
+import asyncio
+from langchain_tensorust import TensorustToolkit
+
+tools = asyncio.run(TensorustToolkit().aget_mcp_tools())
+```
+
+`toolkit.mcp_connection()` returns the connection dict if you already run a
+`MultiServerMCPClient` with other servers.
+
+## API reference
+
+- `TensorustAPIWrapper(api_key=None, base_url=None, timeout=30.0)`: the client. `call(tool, arguments)` / `acall(...)` call any remote tool by name.
+- `TensorustToolkit(api_wrapper=..., include=None)`: `get_tools()`, `aget_mcp_tools()`, `mcp_connection()`.
+- Source: https://github.com/Mattbusel/langchain-tensorust (MIT).

langchain_tensorust-0.1.0/examples/all_mcp_tools.py

@@ -0,0 +1,21 @@
+"""Load every tool on the Tensorust MCP server (about 40) through langchain-mcp-adapters.
+
+pip install "langchain-tensorust[mcp]"
+python examples/all_mcp_tools.py
+"""
+
+import asyncio
+
+from langchain_tensorust import TensorustToolkit
+
+
+async def main() -> None:
+    tools = await TensorustToolkit().aget_mcp_tools()
+    print(f"{len(tools)} tools")
+    for tool in tools:
+        print(f"- {tool.name}: {tool.description.splitlines()[0][:90]}")
+    rule = next(t for t in tools if t.name == "rule_coverage")
+    print(await rule.ainvoke({}))
+
+
+asyncio.run(main())

langchain_tensorust-0.1.0/examples/direct_calls.py

@@ -0,0 +1,24 @@
+"""Call the Tensorust tools directly, no LLM needed. Runs keyless (free previews).
+
+pip install langchain-tensorust
+python examples/direct_calls.py
+"""
+
+import json
+
+from langchain_tensorust import TensorustToolkit
+
+tools = {tool.name: tool for tool in TensorustToolkit().get_tools()}
+
+card = json.loads(tools["tensorust_lookup_organization"].invoke({"name": "Invitation Homes"}))
+subsidiaries = card.get("links", {}).get("~SUBSIDIARY_OF", {}).get("count")
+print(f"{card['name']}: {subsidiaries} subsidiaries on record, sources {card['sources']}")
+
+marks = json.loads(tools["tensorust_lender_marks"].invoke({"company": "Pluralsight"}))
+print(f"{marks['company']}: lowest lender mark {marks['lowest_mark']} ({marks['lowest_manager']})")
+
+screen = json.loads(tools["tensorust_sanctions_screen"].invoke({"name": "Hikvision"}))
+vendors = screen["restricted_vendor_lists"].get("by_vendor", {})
+lists = sorted({name for v in vendors.values() for name in v.get("lists", [])})
+rules = [flag["rule"] for flag in screen["restricted_vendor_lists"].get("flags", [])]
+print(f"Hikvision: {screen['sanctions']['total']} OFAC match(es), lists {lists}, rules {rules}")

langchain_tensorust-0.1.0/examples/kyb_agent.py

@@ -0,0 +1,29 @@
+"""A small KYB / counterparty agent on LangChain v1 with the Tensorust tools.
+
+pip install langchain-tensorust langchain-anthropic
+export ANTHROPIC_API_KEY=...
+export TENSORUST_API_KEY=tdk_...   # optional: full records instead of previews
+python examples/kyb_agent.py "Peraton"
+"""
+
+import sys
+
+from langchain.agents import create_agent
+
+from langchain_tensorust import TensorustToolkit
+
+company = sys.argv[1] if len(sys.argv) > 1 else "Peraton"
+
+agent = create_agent(
+    "anthropic:claude-sonnet-4-6",
+    tools=TensorustToolkit().get_tools(),
+    system_prompt=(
+        "You are a counterparty analyst. Use the Tensorust tools to find who controls the "
+        "company, whether it is on a sanctions or restricted-vendor list, and what its private "
+        "credit lenders mark its loan at. Cite the numbers the tools return. A screen is a "
+        "starting point for review, not a legal determination."
+    ),
+)
+
+result = agent.invoke({"messages": [("user", f"Run a counterparty check on {company}.")]})
+print(result["messages"][-1].content)

langchain_tensorust-0.1.0/langchain_tensorust/__init__.py

@@ -0,0 +1,33 @@
+"""LangChain integration for the Tensorust Ontology.
+
+Ownership, private credit and compliance lookups from US public records (SEC, state business
+registries, county property rolls, FCC, federal awards, OFAC, CMS) as LangChain tools.
+"""
+
+from langchain_tensorust._client import DEFAULT_BASE_URL, TensorustAPIWrapper
+from langchain_tensorust.toolkits import TensorustToolkit
+from langchain_tensorust.tools import (
+    TensorustContractorCredit,
+    TensorustDatasetSearch,
+    TensorustIDROffer,
+    TensorustLenderMarks,
+    TensorustLookupOrganization,
+    TensorustSanctionsScreen,
+    TensorustWhoOwnsHome,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "TensorustAPIWrapper",
+    "TensorustContractorCredit",
+    "TensorustDatasetSearch",
+    "TensorustIDROffer",
+    "TensorustLenderMarks",
+    "TensorustLookupOrganization",
+    "TensorustSanctionsScreen",
+    "TensorustToolkit",
+    "TensorustWhoOwnsHome",
+    "__version__",
+]

langchain_tensorust-0.1.0/langchain_tensorust/_client.py

@@ -0,0 +1,189 @@
+"""HTTP client for the Tensorust Ontology endpoint (JSON-RPC ``tools/call``)."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+from urllib.parse import urlsplit
+
+import httpx
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
+
+DEFAULT_BASE_URL = "https://shop.tensorust.com/api/mcp"
+_LOOPBACK = {"localhost", "127.0.0.1", "::1"}
+_USER_AGENT = "langchain-tensorust"
+
+
+class TensorustAPIWrapper(BaseModel):
+    """Calls the Tensorust Ontology over HTTPS.
+
+    The endpoint speaks MCP's JSON-RPC, so a plain ``tools/call`` POST works without an MCP
+    session or SDK. With no API key every tool answers with its free preview; with a
+    ``tdk_...`` key (argument ``api_key`` or env ``TENSORUST_API_KEY``) the key is sent as a
+    bearer token and tools that support it return the full record.
+
+    Example:
+        ```python
+        from langchain_tensorust import TensorustAPIWrapper
+
+        api = TensorustAPIWrapper()  # keyless: free previews
+        print(api.call("lookup_organization", {"name": "Invitation Homes"}))
+        ```
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    api_key: SecretStr | None = Field(default=None)
+    """Tensorust API key (``tdk_...``). Falls back to ``TENSORUST_API_KEY``. Optional."""
+
+    base_url: str = Field(default="")
+    """Endpoint URL. Falls back to ``TENSORUST_API_URL``, then the public endpoint."""
+
+    timeout: float = 30.0
+    """Request timeout in seconds."""
+
+    @model_validator(mode="before")
+    @classmethod
+    def _from_env(cls, values: Any) -> Any:
+        if not isinstance(values, dict):
+            return values
+        if not values.get("api_key"):
+            key = os.environ.get("TENSORUST_API_KEY", "").strip()
+            if key:
+                values["api_key"] = key
+        if not values.get("base_url"):
+            values["base_url"] = os.environ.get("TENSORUST_API_URL", "").strip() or DEFAULT_BASE_URL
+        return values
+
+    @model_validator(mode="after")
+    def _check_url(self) -> TensorustAPIWrapper:
+        self.base_url = self.base_url.rstrip("/")
+        parsed = urlsplit(self.base_url)
+        ok = bool(parsed.hostname) and (
+            parsed.scheme == "https" or (parsed.scheme == "http" and parsed.hostname in _LOOPBACK)
+        )
+        if not ok:
+            # The key travels as a bearer token, so never send it over plain http to a remote host.
+            msg = f"Tensorust base_url must be an https:// URL with a host, got {self.base_url!r}"
+            raise ValueError(msg)
+        return self
+
+    @property
+    def has_key(self) -> bool:
+        """True when an API key is configured (tools then ask for the full record)."""
+        return bool(self.api_key and self.api_key.get_secret_value().strip())
+
+    def headers(self) -> dict[str, str]:
+        """Request headers, with the bearer token when a key is configured."""
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": _USER_AGENT,
+        }
+        if self.has_key and self.api_key is not None:
+            headers["Authorization"] = f"Bearer {self.api_key.get_secret_value().strip()}"
+        return headers
+
+    def with_full(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        """Add ``full: true`` when a key is configured; keyless calls get the preview."""
+        return {**arguments, "full": True} if self.has_key else arguments
+
+    @staticmethod
+    def payload(tool: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        """The JSON-RPC body for one ``tools/call``."""
+        return {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "tools/call",
+            "params": {"name": tool, "arguments": arguments},
+        }
+
+    def call(self, tool: str, arguments: dict[str, Any]) -> str:
+        """Call one Tensorust tool and return its text answer.
+
+        Raises:
+            ToolException: on a transport error, an HTTP error or a tool error, with a
+                message the agent can act on.
+        """
+        try:
+            response = httpx.post(
+                self.base_url,
+                json=self.payload(tool, arguments),
+                headers=self.headers(),
+                timeout=self.timeout,
+            )
+        except httpx.HTTPError as e:
+            msg = f"Tensorust request failed: {e}"
+            raise ToolException(msg) from e
+        return parse_response(response)
+
+    async def acall(self, tool: str, arguments: dict[str, Any]) -> str:
+        """Async :meth:`call`."""
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(
+                    self.base_url, json=self.payload(tool, arguments), headers=self.headers()
+                )
+        except httpx.HTTPError as e:
+            msg = f"Tensorust request failed: {e}"
+            raise ToolException(msg) from e
+        return parse_response(response)
+
+
+def parse_response(response: httpx.Response) -> str:
+    """Turn a JSON-RPC response into the tool's text, or raise ToolException."""
+    if not response.is_success:
+        label = {
+            401: "Tensorust authentication failed (401): check TENSORUST_API_KEY",
+            402: "This Tensorust call needs a paid key or payment (402)",
+            429: "Tensorust rate limit exceeded (429)",
+        }.get(response.status_code, f"Tensorust API error ({response.status_code})")
+        raise ToolException(label)
+    try:
+        body = response.json()
+    except ValueError as e:
+        msg = "The Tensorust API returned a non-JSON response."
+        raise ToolException(msg) from e
+    if not isinstance(body, dict):
+        msg = "Unexpected response from the Tensorust API."
+        raise ToolException(msg)
+    if body.get("error"):
+        error = body["error"]
+        message = error.get("message") if isinstance(error, dict) else str(error)
+        raise ToolException(f"Tensorust API error: {message}")
+    result = body.get("result")
+    content = result.get("content") if isinstance(result, dict) else None
+    if not isinstance(content, list):
+        msg = "Unexpected response from the Tensorust API."
+        raise ToolException(msg)
+    text = "\n".join(str(part.get("text", "")) for part in content if isinstance(part, dict))
+    if isinstance(result, dict) and result.get("isError"):
+        raise ToolException(text or "The Tensorust tool returned an error.")
+    return text
+
+
+def merge_screen(name: str, sanctions: str, vendors: str) -> str:
+    """Combine the OFAC search and the restricted-vendor screen into one JSON answer."""
+    result: dict[str, Any] = {"name": name}
+    try:
+        found = json.loads(sanctions)
+        result["sanctions"] = {
+            "source": "OFAC sanctions lists",
+            "total": found.get("total", 0),
+            "matches": found.get("items", []),
+        }
+    except (ValueError, AttributeError):
+        result["sanctions"] = {"error": sanctions}
+    try:
+        screen = json.loads(vendors)
+        keep = ("as_of", "lists_pulled", "matched_lines", "by_vendor", "by_rule")
+        section = {key: screen[key] for key in keep if key in screen}
+        section["flags"] = [
+            flag for item in screen.get("items", []) for flag in item.get("flags", [])
+        ]
+        result["restricted_vendor_lists"] = section
+    except (ValueError, AttributeError, TypeError):
+        result["restricted_vendor_lists"] = {"error": vendors}
+    return json.dumps(result, indent=2)

langchain_tensorust-0.1.0/langchain_tensorust/toolkits.py

@@ -0,0 +1,114 @@
+"""TensorustToolkit: the curated tools, or every tool on the Tensorust MCP server."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from langchain_core.tools import BaseTool, BaseToolkit
+from pydantic import ConfigDict, Field
+
+from langchain_tensorust._client import TensorustAPIWrapper
+from langchain_tensorust.tools import (
+    TensorustContractorCredit,
+    TensorustDatasetSearch,
+    TensorustIDROffer,
+    TensorustLenderMarks,
+    TensorustLookupOrganization,
+    TensorustSanctionsScreen,
+    TensorustWhoOwnsHome,
+)
+
+_CURATED = (
+    TensorustLookupOrganization,
+    TensorustWhoOwnsHome,
+    TensorustLenderMarks,
+    TensorustContractorCredit,
+    TensorustSanctionsScreen,
+    TensorustIDROffer,
+    TensorustDatasetSearch,
+)
+
+
+class TensorustToolkit(BaseToolkit):
+    """Ownership, private credit and compliance tools backed by the Tensorust Ontology.
+
+    `get_tools()` returns seven curated tools with typed inputs. `aget_mcp_tools()` loads
+    every tool the Tensorust MCP server exposes (about 40, including the FCC clearinghouse,
+    E-Rate, ROAD Act and research-security exposure tools) through `langchain-mcp-adapters`;
+    install it with `pip install "langchain-tensorust[mcp]"`.
+
+    Both work without a key (free previews). Set `TENSORUST_API_KEY` to a `tdk_...` key for
+    full records.
+
+    Setup:
+        ```bash
+        pip install -U langchain-tensorust
+        export TENSORUST_API_KEY="tdk_..."  # optional
+        ```
+
+    Instantiate:
+        ```python
+        from langchain_tensorust import TensorustToolkit
+
+        toolkit = TensorustToolkit()
+        tools = toolkit.get_tools()
+        ```
+
+    Use within an agent:
+        ```python
+        from langchain.agents import create_agent
+
+        agent = create_agent("anthropic:claude-sonnet-4-6", tools=toolkit.get_tools())
+        agent.invoke({"messages": [("user", "Who controls Invitation Homes?")]})
+        ```
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    api_wrapper: TensorustAPIWrapper = Field(default_factory=TensorustAPIWrapper)
+    """Client shared by every tool. Reads TENSORUST_API_KEY / TENSORUST_API_URL."""
+
+    include: Sequence[str] | None = None
+    """Optional subset of tool names to return from `get_tools()`."""
+
+    def get_tools(self) -> list[BaseTool]:
+        """The curated Tensorust tools, sharing this toolkit's client."""
+        tools: list[BaseTool] = [cls(api_wrapper=self.api_wrapper) for cls in _CURATED]
+        if self.include is not None:
+            wanted = set(self.include)
+            unknown = wanted - {t.name for t in tools}
+            if unknown:
+                msg = f"Unknown Tensorust tool names: {sorted(unknown)}"
+                raise ValueError(msg)
+            tools = [t for t in tools if t.name in wanted]
+        return tools
+
+    def mcp_connection(self) -> dict[str, Any]:
+        """The `langchain-mcp-adapters` connection for the Tensorust MCP server."""
+        headers = {
+            k: v
+            for k, v in self.api_wrapper.headers().items()
+            if k in {"Authorization", "User-Agent"}
+        }
+        return {
+            "transport": "streamable_http",
+            "url": self.api_wrapper.base_url,
+            "headers": headers,
+        }
+
+    async def aget_mcp_tools(self) -> list[BaseTool]:
+        """Every tool on the Tensorust MCP server, as LangChain tools.
+
+        Requires `pip install "langchain-tensorust[mcp]"`.
+        """
+        try:
+            from langchain_mcp_adapters.client import MultiServerMCPClient
+        except ImportError as e:  # pragma: no cover - exercised only without the extra
+            msg = (
+                "aget_mcp_tools needs langchain-mcp-adapters: "
+                'pip install "langchain-tensorust[mcp]"'
+            )
+            raise ImportError(msg) from e
+        client = MultiServerMCPClient({"tensorust": self.mcp_connection()})  # type: ignore[dict-item]
+        return list(await client.get_tools())