Integrations

Drop-in support for LangChain, Anthropic, OpenAI, and MCP.

The SDK integrates with major AI frameworks. Each integration captures tool calls automatically — no need to wrap every function with @quint.guard().

Anthropic Messages API

import anthropic
import quint_agent
from quint_agent.integrations.anthropic import guarded_dispatch

quint_agent.init(api_key="qak_...")
client = anthropic.Anthropic()

tools_map = {
    "read_file": read_file,
    "run_command": run_command,
    "query_db": query_db,
}

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[...],  # your tool definitions
    messages=[{"role": "user", "content": "Analyze the codebase"}],
)

for block in response.content:
    if block.type == "tool_use":
        # guarded_dispatch captures + policy-checks before executing
        result = guarded_dispatch(block.name, block.input, tools_map)

guarded_dispatch handles the full lifecycle:

1. Emits a tool_call event with the tool name and arguments
2. Evaluates the call against your YAML policy
3. If blocked, raises ToolBlockedError (return this as a tool error to Claude)
4. If allowed, executes the function and emits a tool_result event

LangChain

from langchain_anthropic import ChatAnthropic
from langchain.agents import create_tool_calling_agent, AgentExecutor
from quint_agent.integrations.langchain import QuintCallbackHandler

quint_agent.init(api_key="qak_...")

llm = ChatAnthropic(model="claude-sonnet-4-6")
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# The callback handler captures every tool call automatically
executor.invoke(
    {"input": "What files are in the project?"},
    config={"callbacks": [QuintCallbackHandler()]},
)

The callback handler hooks into LangChain’s event system:

• on_tool_start → emits tool_call + runs policy check
• on_tool_end → emits tool_result
• on_tool_error → emits tool_error

MCP (Model Context Protocol)

from quint_agent.integrations.mcp import QuintMCPClient

quint_agent.init(api_key="qak_...")

async with mcp_client() as session:
    guarded = QuintMCPClient(session)

    # Every call_tool goes through Quint's policy engine
    result = await guarded.call_tool("read_file", {"path": "/etc/hosts"})

QuintMCPClient wraps the MCP session and intercepts call_tool:

• Captures the tool name and arguments
• Runs policy evaluation
• Delegates to the underlying MCP session if allowed

OpenAI Function Calling

from openai import OpenAI
from quint_agent.integrations.openai import guarded_function_call

quint_agent.init(api_key="qak_...")
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    tools=[...],
    messages=[{"role": "user", "content": "Read the config"}],
)

for choice in response.choices:
    for call in choice.message.tool_calls or []:
        result = guarded_function_call(
            call.function.name,
            json.loads(call.function.arguments),
            tools_map,
        )

Using without a framework

If you’re building a custom agent loop, use @quint.guard() directly:

import quint_agent

quint_agent.init(api_key="qak_...")

@quint_agent.guard()
def read_file(path: str) -> str:
    return open(path).read()

@quint_agent.guard()
def write_file(path: str, content: str) -> None:
    with open(path, "w") as f:
        f.write(content)

@quint_agent.guard(name="shell")  # custom tool name
def run(cmd: str) -> str:
    import subprocess
    return subprocess.check_output(cmd, shell=True, text=True)

The @guard() decorator works with both sync and async functions.