langchain-tensorust 0.1.0__py3-none-any.whl

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/_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/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())

langchain_tensorust/tools.py

@@ -0,0 +1,332 @@
+"""LangChain tools for the Tensorust Ontology: ownership, private credit and compliance lookups."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_core.callbacks import AsyncCallbackManagerForToolRun, CallbackManagerForToolRun
+from langchain_core.tools import BaseTool, ToolException
+from pydantic import BaseModel, Field
+
+from langchain_tensorust._client import TensorustAPIWrapper, merge_screen
+
+
+class _TensorustTool(BaseTool):
+    """Shared plumbing: one Tensorust tool call per invocation, sync and async."""
+
+    api_wrapper: TensorustAPIWrapper = Field(default_factory=TensorustAPIWrapper)
+    """Client for the Tensorust endpoint. Reads TENSORUST_API_KEY / TENSORUST_API_URL."""
+
+    handle_tool_error: bool = True
+    """Return Tensorust errors (bad input, 401, 429) to the agent as text instead of raising."""
+
+    #: Name of the remote tool this class calls.
+    remote_tool: str = ""
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def _run(self, run_manager: CallbackManagerForToolRun | None = None, **kwargs: Any) -> str:
+        return self.api_wrapper.call(self.remote_tool, self._arguments(**kwargs))
+
+    async def _arun(
+        self, run_manager: AsyncCallbackManagerForToolRun | None = None, **kwargs: Any
+    ) -> str:
+        return await self.api_wrapper.acall(self.remote_tool, self._arguments(**kwargs))
+
+
+def _required(value: str | None, what: str) -> str:
+    value = (value or "").strip()
+    if not value:
+        raise ToolException(f"{what} is required.")
+    return value
+
+
+class OrganizationInput(BaseModel):
+    """Input for TensorustLookupOrganization."""
+
+    name: str = Field(
+        description="Organization name, e.g. 'Invitation Homes' or 'Lockheed Martin'."
+    )
+
+
+class TensorustLookupOrganization(_TensorustTool):
+    """Find out who owns or controls a US company or organization.
+
+    Resolves a name to its legal entity or control group and returns its data sources, linked
+    objects by type (subsidiaries, parent, homes owned, FCC licenses, federal awards, lobbying)
+    and the federal rules that apply to it, with other close name matches.
+
+    Setup:
+        ```bash
+        pip install -U langchain-tensorust
+        export TENSORUST_API_KEY="tdk_..."  # optional: without it you get the free preview
+        ```
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustLookupOrganization
+
+        tool = TensorustLookupOrganization()
+        tool.invoke({"name": "Invitation Homes"})
+        ```
+    """
+
+    name: str = "tensorust_lookup_organization"
+    description: str = (
+        "Look up who owns or controls a US company or organization from public records "
+        "(SEC subsidiary lists, state business registries, county property rolls, FCC, "
+        "federal awards). Input: the organization name. Returns JSON with the parent or "
+        "control group, linked subsidiaries, homes, licenses and awards, and the federal "
+        "rules that apply to it."
+    )
+    args_schema: type[BaseModel] = OrganizationInput
+    remote_tool: str = "lookup_organization"
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        return self.api_wrapper.with_full(
+            {"name": _required(kwargs.get("name"), "An organization name")}
+        )
+
+
+class HomeInput(BaseModel):
+    """Input for TensorustWhoOwnsHome."""
+
+    address: str = Field(description="Street address, e.g. '2746 Lofty Elm St'.")
+    zip_code: str = Field(description="5-digit ZIP code, e.g. '77494'.")
+
+
+class TensorustWhoOwnsHome(_TensorustTool):
+    """Find the owner of record of a US single-family home and its parent control group.
+
+    Coverage is entity-owned homes in 17 large counties (Houston, Dallas, Fort Worth,
+    San Antonio, Austin, Phoenix, Las Vegas, Atlanta, Tampa, Orlando, Jacksonville,
+    Charlotte, Memphis and others).
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustWhoOwnsHome
+
+        TensorustWhoOwnsHome().invoke({"address": "2746 Lofty Elm St", "zip_code": "77494"})
+        ```
+    """
+
+    name: str = "tensorust_who_owns_home"
+    description: str = (
+        "Find the owner of record of a US single-family home by street address and ZIP, and, "
+        "when the owner is a company, its parent control group, how many homes the group holds "
+        "and whether it counts as a large institutional investor (350+ homes)."
+    )
+    args_schema: type[BaseModel] = HomeInput
+    remote_tool: str = "who_owns_home"
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        return {
+            "address": _required(kwargs.get("address"), "A street address"),
+            "zip": _required(kwargs.get("zip_code"), "A ZIP code"),
+        }
+
+
+class CompanyInput(BaseModel):
+    """Input for the private credit tools."""
+
+    company: str = Field(description="Company name, e.g. 'Pluralsight'.")
+
+
+class TensorustLenderMarks(_TensorustTool):
+    """See what private credit lenders (BDCs) say a company's first-lien loan is worth.
+
+    Returns the fair value each BDC fund holding the loan reported in its latest 10-Q, as a
+    share of par, with the manager and the gap between the lowest and highest mark.
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustLenderMarks
+
+        TensorustLenderMarks().invoke({"company": "Pluralsight"})
+        ```
+    """
+
+    name: str = "tensorust_lender_marks"
+    description: str = (
+        "Get what private credit lenders (BDC funds such as Ares, Blue Owl, Golub) marked a "
+        "private company's first-lien loan at in their latest 10-Q filings, as a share of par, "
+        "and how far the lenders disagree. A low or widely split mark is an early sign of "
+        "credit stress. Input: the borrower's name."
+    )
+    args_schema: type[BaseModel] = CompanyInput
+    remote_tool: str = "lender_marks"
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        return self.api_wrapper.with_full(
+            {"name": _required(kwargs.get("company"), "A company name")}
+        )
+
+
+class ContractorInput(BaseModel):
+    """Input for TensorustContractorCredit."""
+
+    company: str = Field(
+        description="Contractor name, 12-character UEI or 9-digit EIN, e.g. 'Peraton'."
+    )
+
+
+class TensorustContractorCredit(_TensorustTool):
+    """Check the credit health of a US federal contractor financed by private credit.
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustContractorCredit
+
+        TensorustContractorCredit().invoke({"company": "Peraton"})
+        ```
+    """
+
+    name: str = "tensorust_contractor_credit"
+    description: str = (
+        "Check the credit health of a US federal contractor: its federal obligations by agency, "
+        "what each private credit lender marks its loan at and how the mark moved, its "
+        "headcount trend and stress signals. Input: contractor name, UEI or EIN."
+    )
+    args_schema: type[BaseModel] = ContractorInput
+    remote_tool: str = "contractor_credit"
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        return self.api_wrapper.with_full(
+            {"name": _required(kwargs.get("company"), "A contractor name")}
+        )
+
+
+class ScreenInput(BaseModel):
+    """Input for TensorustSanctionsScreen."""
+
+    name: str = Field(description="Company or vendor name, e.g. 'Hikvision'.")
+
+
+class TensorustSanctionsScreen(_TensorustTool):
+    """Screen a company or vendor name against OFAC and the US restricted-vendor lists.
+
+    Checks OFAC sanctions and the DoD 1260H, Section 889, FCC Covered List, UFLPA and
+    BIOSECURE lists, and returns each hit with the rule and citation. A screen is a starting
+    point for review, not a legal determination.
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustSanctionsScreen
+
+        TensorustSanctionsScreen().invoke({"name": "Hikvision"})
+        ```
+    """
+
+    name: str = "tensorust_sanctions_screen"
+    description: str = (
+        "Screen a company or vendor name against the OFAC sanctions lists and the US "
+        "restricted-vendor lists (DoD 1260H, Section 889, FCC Covered List, UFLPA, BIOSECURE). "
+        "Returns JSON with each match, the rule it triggers and the citation."
+    )
+    args_schema: type[BaseModel] = ScreenInput
+    remote_tool: str = "query_ontology"
+
+    @staticmethod
+    def _screen_args(name: str) -> tuple[dict[str, Any], dict[str, Any]]:
+        return {"name": name, "type": "Sanction", "limit": 10}, {"lines": [{"vendor": name}]}
+
+    def _run(self, run_manager: CallbackManagerForToolRun | None = None, **kwargs: Any) -> str:
+        name = _required(kwargs.get("name"), "A company or vendor name")
+        sanctions_args, vendor_args = self._screen_args(name)
+        sanctions = self.api_wrapper.call("query_ontology", sanctions_args)
+        vendors = self.api_wrapper.call("exposure_screen_purchases", vendor_args)
+        return merge_screen(name, sanctions, vendors)
+
+    async def _arun(
+        self, run_manager: AsyncCallbackManagerForToolRun | None = None, **kwargs: Any
+    ) -> str:
+        name = _required(kwargs.get("name"), "A company or vendor name")
+        sanctions_args, vendor_args = self._screen_args(name)
+        sanctions = await self.api_wrapper.acall("query_ontology", sanctions_args)
+        vendors = await self.api_wrapper.acall("exposure_screen_purchases", vendor_args)
+        return merge_screen(name, sanctions, vendors)
+
+
+class IDROfferInput(BaseModel):
+    """Input for TensorustIDROffer."""
+
+    code: str = Field(description="CPT or HCPCS code, e.g. '99284'.")
+    payer: str | None = Field(
+        default=None, description="Payer email domain or common name, e.g. 'uhc.com' or 'Aetna'."
+    )
+    state: str | None = Field(default=None, description="Two-letter state of service, e.g. 'TX'.")
+    qpa: float | None = Field(
+        default=None,
+        description="Qualifying payment amount in dollars, to get the band in dollars.",
+    )
+
+
+class TensorustIDROffer(_TensorustTool):
+    """No Surprises Act arbitration (federal IDR) outcomes for a billing code.
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustIDROffer
+
+        TensorustIDROffer().invoke({"code": "99284", "payer": "uhc.com", "state": "TX"})
+        ```
+    """
+
+    name: str = "tensorust_idr_offer"
+    description: str = (
+        "Look up federal No Surprises Act arbitration (IDR) outcomes from the CMS public use "
+        "file: for a CPT/HCPCS code, payer and state, how many disputes were decided, how often "
+        "the provider won and which offer band (as multiples of the QPA) won."
+    )
+    args_schema: type[BaseModel] = IDROfferInput
+    remote_tool: str = "idr_offer"
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        arguments: dict[str, Any] = {"code": _required(kwargs.get("code"), "A CPT or HCPCS code")}
+        payer = (kwargs.get("payer") or "").strip()
+        state = (kwargs.get("state") or "").strip()
+        if payer:
+            arguments["payer"] = payer
+        if state:
+            arguments["state"] = state.upper()
+        if kwargs.get("qpa") is not None:
+            arguments["qpa"] = kwargs["qpa"]
+        return arguments
+
+
+class DatasetSearchInput(BaseModel):
+    """Input for TensorustDatasetSearch."""
+
+    query: str = Field(
+        description="Words to match, e.g. 'going concern', 'E-Rate', 'BDC non-accrual'."
+    )
+    limit: int = Field(default=10, ge=1, le=50, description="Maximum datasets to return.")
+
+
+class TensorustDatasetSearch(_TensorustTool):
+    """Search the Tensorust catalog of entity-level datasets built from public records.
+
+    Invocation:
+        ```python
+        from langchain_tensorust import TensorustDatasetSearch
+
+        TensorustDatasetSearch().invoke({"query": "BDC non-accrual"})
+        ```
+    """
+
+    name: str = "tensorust_dataset_search"
+    description: str = (
+        "Search a catalog of entity-level datasets built from US public records (SEC, "
+        "USAspending, FCC, CMS, EPA, DOL, county rolls): money owed, at risk, unclaimed or "
+        "about to expire, one row per organization. Returns each dataset's name, row count, "
+        "page and free sample CSV link."
+    )
+    args_schema: type[BaseModel] = DatasetSearchInput
+    remote_tool: str = "list_datasets"
+
+    def _arguments(self, **kwargs: Any) -> dict[str, Any]:
+        return {
+            "query": _required(kwargs.get("query"), "A search query"),
+            "limit": int(kwargs.get("limit") or 10),
+        }

langchain_tensorust-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,9 @@
+langchain_tensorust/__init__.py,sha256=UnA-ANAfNBeXMz2OA8pB7pW6xkRWQE9Ru7XVouDt__8,957
+langchain_tensorust/_client.py,sha256=wcB1npaWia-OBkC5mLjZ3cfaNUYpG7YQoSCLa-200QM,7604
+langchain_tensorust/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_tensorust/toolkits.py,sha256=54KKF9ohyBXvclAi-pdvZ1XmRKFpE82Ztted9HhUoTk,4019
+langchain_tensorust/tools.py,sha256=Cb9nhQotWADopohNKANFVX1XqYRNXG9hFjTEd7D4Oa0,12601
+langchain_tensorust-0.1.0.dist-info/METADATA,sha256=Jk1I9fZme3EbrRieu0xI6-wb1lHUqe-AtqoV2MRuRaE,3283
+langchain_tensorust-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+langchain_tensorust-0.1.0.dist-info/licenses/LICENSE,sha256=TpCqwl9Iq4EFUnYGbR2dGUSmF5tDy-hCISSPJasaP10,1070
+langchain_tensorust-0.1.0.dist-info/RECORD,,

langchain_tensorust-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

langchain_tensorust-0.1.0.dist-info/licenses/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.