Integrations - TealTiger Docs

TealTiger integrates with popular AI frameworks and tools to add security, cost control, and governance to your existing stack.

How integrations work

TealTiger integrations wrap your existing code to add policy enforcement: Every integration provides:

Policy enforcement - Control what agents can do
Cost tracking - Monitor and limit spending
Audit logging - Track all decisions
Zero code changes - Drop-in replacements

Agent frameworks

Integrate TealTiger with popular agent frameworks:

LangChain

Add governance to LangChain agents and tools

CrewAI

Control multi-agent CrewAI workflows

OpenClaw

Secure local-first agents with system access

MCP

Govern Model Context Protocol tools

Observability & monitoring

Export TealTiger data to your observability stack:

OpenTelemetry

Export traces and metrics to OTel

Langfuse

LLM observability and tracing

LangSmith

Debug and monitor LangChain apps

Helicone

LLM proxy and observability

Datadog / Splunk

SIEM and APM via OTLP bridge

Slack / Discord

Real-time alert webhooks

Integration patterns

TealTiger supports three integration patterns:

Pattern 1: Drop-in wrapper

Replace your existing client with a TealTiger-wrapped version:

// Before
import { ChatOpenAI } from 'langchain/chat_models/openai';
const model = new ChatOpenAI();

// After
import { TealEngine } from 'tealtiger';
import { ChatOpenAI } from 'langchain/chat_models/openai';

const engine = new TealEngine({ policies: { /* ... */ } });
const model = engine.wrap(new ChatOpenAI());

Pattern 2: Pre-action hook

Intercept actions before they execute:

import { TealEngine } from 'tealtiger';

const engine = new TealEngine({ policies: { /* ... */ } });

// Intercept tool calls
agent.onToolCall(async (tool, args) => {
  const decision = await engine.evaluate({
    action: 'tool.execute',
    tool: tool.name,
    arguments: args
  });
  
  if (decision.action === 'DENY') {
    throw new Error('Tool blocked by policy');
  }
  
  return tool.execute(args);
});

Pattern 3: Telemetry export

Export TealTiger decisions to your observability stack:

import { TealEngine } from 'tealtiger';

const engine = new TealEngine({
  policies: { /* ... */ },
  audit: {
    outputs: ['opentelemetry', 'langfuse']
  }
});

Quick start

Here’s a complete example integrating TealTiger with LangChain:

import { TealEngine, PolicyMode } from 'tealtiger';
import { ChatOpenAI } from 'langchain/chat_models/openai';
import { initializeAgentExecutorWithOptions } from 'langchain/agents';
import { Calculator } from 'langchain/tools/calculator';

// Initialize TealTiger
const engine = new TealEngine({
  policies: {
    tools: {
      calculator: { allowed: true },
      web_search: { allowed: false }
    },
    budget: {
      maxCostPerRequest: 0.50,
      maxCostPerDay: 100.00
    }
  },
  mode: {
    defaultMode: PolicyMode.ENFORCE
  }
});

// Wrap the model
const model = engine.wrap(new ChatOpenAI({
  modelName: 'gpt-4',
  temperature: 0
}));

// Create agent with wrapped model
const tools = [new Calculator()];
const agent = await initializeAgentExecutorWithOptions(
  tools,
  model,
  {
    agentType: 'zero-shot-react-description'
  }
);

// Use the agent (now with governance)
const result = await agent.call({
  input: 'What is 25 * 4?'
});

console.log(result.output);
// TealTiger automatically:
// - Checks policies before each tool call
// - Tracks costs
// - Logs all decisions

from tealtiger import TealEngine, PolicyMode
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool

# Initialize TealTiger
engine = TealEngine({
    "policies": {
        "tools": {
            "calculator": {"allowed": True},
            "web_search": {"allowed": False}
        },
        "budget": {
            "maxCostPerRequest": 0.50,
            "maxCostPerDay": 100.00
        }
    },
    "mode": {
        "defaultMode": PolicyMode.ENFORCE
    }
})

# Wrap the model
model = engine.wrap(ChatOpenAI(
    model_name="gpt-4",
    temperature=0
))

# Create agent with wrapped model
tools = [
    Tool(
        name="Calculator",
        func=lambda x: eval(x),
        description="Useful for math calculations"
    )
]

agent = initialize_agent(
    tools,
    model,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)

# Use the agent (now with governance)
result = agent.run("What is 25 * 4?")

print(result)
# TealTiger automatically:
# - Checks policies before each tool call
# - Tracks costs
# - Logs all decisions

What integrations provide

Every TealTiger integration gives you:

Security controls

Block dangerous tools
Enforce role-based access
Detect prompt injection
Redact sensitive data

Cost management

Set budget limits
Track spending per request
Prevent runaway costs
Downgrade expensive models

Compliance

Audit all decisions
Redact PII automatically
Maintain evidence trails
Meet regulatory requirements

Reliability

Circuit breakers
Rate limiting
Timeout controls
Graceful degradation

Integration status

Integration	Status	Documentation
LangChain	✅ Available	View docs
CrewAI	✅ Available	View docs
OpenClaw	✅ Available	View docs
MCP	✅ Available	View docs
OpenTelemetry	✅ Available	View docs
Langfuse	✅ Available	View docs
LangSmith	✅ Available	View docs
Helicone	✅ Available	View docs
Datadog	✅ Available (via OTLP)	View docs
Splunk	✅ Available (via OTLP)	View docs
Slack / Discord	✅ Available	View docs

Need a custom integration?

Building a custom integration is straightforward:

Identify the boundary - Where do you want to enforce policies? (model calls, tool execution, etc.)
Wrap the call - Add engine.evaluate() before the action
Handle the decision - Act on ALLOW, DENY, TRANSFORM, etc.
Log the event - TealTiger handles audit logging automatically

Example custom integration:

class CustomTool {
  constructor(private engine: TealEngine) {}
  
  async execute(action: string, args: any) {
    // Evaluate policy
    const decision = await this.engine.evaluate({
      action: 'tool.execute',
      tool: action,
      arguments: args
    });
    
    // Handle decision
    if (decision.action === 'DENY') {
      throw new Error(`Blocked: ${decision.reason_codes.join(', ')}`);
    }
    
    // Execute the action
    return await this.performAction(action, args);
  }
}

Get help

Need help with an integration?

Email: [email protected]
GitHub: github.com/agentguard-ai/tealtiger
Documentation: docs.tealtiger.ai

Next steps

LangChain integration

Get started with LangChain

Policy overview

Learn how to write policies

Cookbook

See real-world examples

API reference

Explore the API

​How integrations work

​Agent frameworks

LangChain

CrewAI

OpenClaw

MCP

​Observability & monitoring

OpenTelemetry

Langfuse

LangSmith

Helicone

Datadog / Splunk

Slack / Discord

​Integration patterns

​Pattern 1: Drop-in wrapper

​Pattern 2: Pre-action hook

​Pattern 3: Telemetry export

​Quick start

​What integrations provide

​Security controls

​Cost management

​Compliance

​Reliability

​Integration status

​Need a custom integration?

​Get help

​Next steps