LangGraph Integration

pip install "agentrust-py[langgraph]"

export AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech
export AGENTRUST_KEY=at_live_...
export AGENTRUST_AGENT_ID=support-agent

+ import os
+ from agentrust_sdk.adapters.langgraph import governed_tools

  tools = [lookup_order, issue_refund]
+ tools = governed_tools(
+     tools, agent_id=os.environ["AGENTRUST_AGENT_ID"]
+ )

  agent = create_agent(model, tools=tools)

  tools = [lookup_order, issue_refund]
+ tools = governed_tools(
+     tools, agent_id=os.environ["AGENTRUST_AGENT_ID"]
+ )

  model_with_tools = model.bind_tools(tools)
  graph.add_node("tools", ToolNode(tools))

Blocked by AgentTrust: Tool-trust hard gate: tool_trust: 'issue_refund' amount 500.0 exceeds declared max_amount 100.0 (envelope …)

pip install "agentrust-py[langgraph,embedded]"

from agentrust_sdk.embedded import embed_gateway

gateway = embed_gateway()
gateway.register_manifest("support-agent", {
    "declared_tools": [
        {"name": "lookup_order"},
        {"name": "issue_refund", "max_amount": 100},
    ],
})

mkdir agentrust-quickstart && cd agentrust-quickstart
python -m venv .venv && source .venv/bin/activate     # on Windows: .venv\Scripts\activate
pip install "agentrust-py[langgraph,embedded]" "langchain>=1.0" langchain-ollama
ollama pull llama3.1

"""
langgraph_quickstart.py — a LangGraph agent whose tool calls AgentTrust checks.

The agent is the calculator from LangGraph's own quickstart: a chat model with
add, multiply and divide tools, in a loop that runs until the model answers
without asking for a tool.

AgentTrust is one line (marked "AgentTrust" below): the tools are wrapped with
governed_tools. Every call is checked before it runs, and its result after. A
tool the agent may not use is refused before its code runs; the model is told
why and the graph still finishes. The agent may use add and multiply, not divide.

RUN IT (in the folder that holds this file)
    pip install "agentrust-py[langgraph,embedded]" "langchain>=1.0" langchain-ollama
    ollama pull llama3.1                                  # a free model with tool calling

    python langgraph_quickstart.py --without-agentrust    # AgentTrust off: every tool runs
    python langgraph_quickstart.py --local                # a gateway starts inside this program; no account
    python langgraph_quickstart.py --console              # your AgentTrust console keeps every decision

  --console needs three settings, from the agent you create in the console:
      export AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech
      export AGENTRUST_KEY=at_live_...
      export AGENTRUST_AGENT_ID=...

ANOTHER MODEL
    QUICKSTART_MODEL=anthropic:claude-sonnet-4-6 (pip install langchain-anthropic,
    export ANTHROPIC_API_KEY). Any init_chat_model string for a model that
    supports tool calling works.
"""
from __future__ import annotations

import argparse
import operator
import os
import sys
import tempfile
from typing import Annotated, Literal

from langchain.chat_models import init_chat_model
from langchain.messages import AnyMessage, HumanMessage, SystemMessage
from langchain.tools import tool
from langgraph.graph import END, START, StateGraph
from typing_extensions import TypedDict

from agentrust_sdk.adapters.langgraph import governed_tools

AGENT_ID = os.environ.get("AGENTRUST_AGENT_ID", "calculator-agent")
MODEL = os.environ.get("QUICKSTART_MODEL", "ollama:llama3.1")

# The tools this agent may call. With --local they are set here; with --console
# you declare the same list on the agent in the console. divide is left out on purpose.
MANIFEST = {"declared_tools": [{"name": "add"}, {"name": "multiply"}]}

# Step 1: Define tools
@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`.

    Args:
        a: First int
        b: Second int
    """
    return a * b

@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`.

    Args:
        a: First int
        b: Second int
    """
    return a + b

@tool
def divide(a: int, b: int) -> float:
    """Divide `a` and `b`.

    Args:
        a: First int
        b: Second int
    """
    return a / b

# AgentTrust: every call to these tools is checked before it runs and after it
# returns. Use this same list for bind_tools and for the tool node.
tools = governed_tools([add, multiply, divide], agent_id=AGENT_ID)
tools_by_name = {t.name: t for t in tools}

# Step 2: Define state
class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int

# Step 4: Define tool node
def tool_node(state: MessagesState) -> dict:
    """Performs the tool calls the model asked for."""
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        t = tools_by_name[tool_call["name"]]
        # Invoking with the whole tool call returns a ToolMessage. A call
        # AgentTrust refuses comes back as ToolMessage(status="error").
        result.append(t.invoke(tool_call))
    return {"messages": result}

# Step 5: Define end logic
def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    """Route to the tool node if the model made a tool call, else stop."""
    if state["messages"][-1].tool_calls:
        return "tool_node"
    return END

# Steps 3 and 6: Define the model node, then build and compile the agent
def build_agent(model):
    model_with_tools = model.bind_tools(tools)

    def llm_call(state: MessagesState) -> dict:
        """LLM decides whether to call a tool or not."""
        return {
            "messages": [
                model_with_tools.invoke(
                    [SystemMessage(content="You are a helpful assistant tasked with performing arithmetic on a set of inputs.")]
                    + state["messages"]
                )
            ],
            "llm_calls": state.get("llm_calls", 0) + 1,
        }

    agent_builder = StateGraph(MessagesState)
    agent_builder.add_node("llm_call", llm_call)
    agent_builder.add_node("tool_node", tool_node)
    agent_builder.add_edge(START, "llm_call")
    agent_builder.add_conditional_edges("llm_call", should_continue, ["tool_node", END])
    agent_builder.add_edge("tool_node", "llm_call")
    return agent_builder.compile()

def ask_agent(where: str) -> bool:
    """Ask the agent to add, then to divide. False if the model can't be reached."""
    print(f"AgentTrust: {where} · agent {AGENT_ID} · model {MODEL}")
    agent = build_agent(init_chat_model(MODEL, temperature=0))
    try:
        for request in ["Add 3 and 4.", "Divide 10 by 2."]:
            print(f"\n=== {request} ===")
            state = agent.invoke({"messages": [HumanMessage(content=request)]})
            for m in state["messages"]:
                m.pretty_print()
    except Exception as exc:  # noqa: BLE001 - any provider error ends the run
        print(f"\nThe model call failed ({MODEL}): {exc}\n"
              "Check the model provider is reachable (Ollama: `ollama serve` and `ollama pull llama3.1`).",
              file=sys.stderr)
        return False
    return True

# --without-agentrust: every tool runs. For comparison.
def run_without_agentrust() -> int:
    os.environ["AGENTRUST_ENABLED"] = "false"   # the SDK's off switch: wrapped tools pass every call through
    return 0 if ask_agent("off (every tool runs)") else 1

# --local: a gateway runs inside this program; no account needed.
def run_local() -> int:
    from agentrust_sdk.embedded import embed_gateway

    # SQLite in a temp dir, gone after the run. embed_gateway sets
    # AGENTRUST_GATEWAY_URL and AGENTRUST_KEY, which governed_tools reads.
    gateway = embed_gateway(db_path=os.path.join(tempfile.mkdtemp(), "gateway.db"))
    gateway.register_manifest(AGENT_ID, MANIFEST)
    try:
        ok = ask_agent(f"local gateway {gateway.url} (no account, nothing kept)")
    finally:
        gateway.stop()
    return 0 if ok else 1

# --console: the SDK sends every check to your console, which keeps the decisions.
def run_with_console() -> int:
    missing = [v for v in ("AGENTRUST_GATEWAY_URL", "AGENTRUST_KEY", "AGENTRUST_AGENT_ID") if not os.environ.get(v)]
    if missing:
        print(f"Set {', '.join(missing)} (from the agent you created in the console), or use --local.",
              file=sys.stderr)
        return 2
    console = os.environ["AGENTRUST_GATEWAY_URL"]
    ok = ask_agent(f"console {console}")
    print(f"\nOpen Events in the console ({console}) and filter by agent ID {AGENT_ID}.")
    return 0 if ok else 1

def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description="The LangGraph calculator agent, governed by AgentTrust.")
    where = parser.add_mutually_exclusive_group()
    where.add_argument("--local", action="store_true", help="run a gateway inside this program, no account (the default)")
    where.add_argument("--console", action="store_true", help="send every check to your AgentTrust console")
    where.add_argument("--without-agentrust", action="store_true", help="for comparison: AgentTrust off, every tool runs")
    args = parser.parse_args(argv)
    if args.without_agentrust:
        return run_without_agentrust()
    return run_with_console() if args.console else run_local()

if __name__ == "__main__":
    sys.exit(main())

python langgraph_quickstart.py --help

usage: langgraph_quickstart.py [-h]
                               [--local | --console | --without-agentrust]

python langgraph_quickstart.py --without-agentrust

AgentTrust: off (every tool runs) · agent calculator-agent · model ollama:llama3.1
...
=== Divide 10 by 2. ===
...
Name: divide

5.0

+ from agentrust_sdk.adapters.langgraph import governed_tools

- tools = [add, multiply, divide]
+ tools = governed_tools([add, multiply, divide], agent_id=AGENT_ID)

  model_with_tools = model.bind_tools(tools)   # the wrapped list here
  graph.add_node("tools", ToolNode(tools))     # and here

python langgraph_quickstart.py --local

AgentTrust: local gateway http://127.0.0.1:8765 (no account, nothing kept) · agent calculator-agent · model ollama:llama3.1
...
=== Add 3 and 4. ===
...
Name: add

7
...
=== Divide 10 by 2. ===
...
Name: divide

Blocked by AgentTrust: Tool-trust hard gate: action 'divide' is not in this agent's declared_tools (envelope 43c1d418-…)

AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech   # your console's address
AGENTRUST_KEY=at_live_...                                # the API key from step 5
AGENTRUST_AGENT_ID=langgraph-quickstart                  # the Agent ID from step 5

# Optional
AGENTRUST_FAILURE_MODE=closed     # refuse tool calls when AgentTrust can't be reached (default: open)

export AGENTRUST_GATEWAY_URL=https://console.agent-trust.tech   # your console's address
export AGENTRUST_KEY=at_live_...                                # the API key
export AGENTRUST_AGENT_ID=langgraph-quickstart                  # the Agent ID

python langgraph_quickstart.py --console

AgentTrust: console http://127.0.0.1:18000 · agent langgraph-quickstart · model ollama:llama3.1
...
Name: divide

Blocked by AgentTrust: Tool-trust hard gate: tool_trust: action 'divide' is not in this agent's declared_tools (envelope d05dc011-…)

Open Events in the console (http://127.0.0.1:18000) and filter by agent ID langgraph-quickstart.