LangChain Integration

Overview

The Secure MCP Gateway provides two Python modules for protecting LangChain and LangGraph applications:

LangChain Module - BaseCallbackHandler for any LangChain component
LangGraph Module - pre_model_hook and post_model_hook for LangGraph agents

Use the EnkryptGuardrailsHandler to protect any LangChain component including LLMs, chains, agents, tools, and retrievers.

Installation

cd hooks/langchain
pip install -r requirements.txt

Configure Guardrails

cp guardrails_config_example.json guardrails_config.json
# Edit with your API key

export ENKRYPT_API_KEY="your-api-key"

Basic Usage

from langchain_openai import ChatOpenAI
from enkrypt_guardrails_handler import EnkryptGuardrailsHandler

# Create the guardrails handler
handler = EnkryptGuardrailsHandler()

# Use with any LangChain component
llm = ChatOpenAI(model="gpt-4", callbacks=[handler])

# The handler will automatically validate inputs and monitor outputs
response = llm.invoke("What is the weather today?")

Supported Hooks

The EnkryptGuardrailsHandler implements all LangChain BaseCallbackHandler methods:

Hook	Description	Default Checks
`on_llm_start`	Before LLM call	injection_attack, pii, toxicity
`on_llm_end`	After LLM response	pii, toxicity, nsfw
`on_chat_model_start`	Before chat model call	injection_attack, pii, toxicity
`on_chain_start`	Before chain execution	injection_attack, pii
`on_chain_end`	After chain completion	pii, toxicity
`on_tool_start`	Before tool execution	injection_attack, pii
`on_tool_end`	After tool execution	pii
`on_agent_action`	On agent decision	injection_attack
`on_agent_finish`	On agent completion	pii, toxicity, nsfw
`on_retriever_start`	Before retriever query	injection_attack
`on_retriever_end`	After document retrieval	pii

Usage Examples

With Chains

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from enkrypt_guardrails_handler import EnkryptGuardrailsHandler

handler = EnkryptGuardrailsHandler()

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{input}")
])

llm = ChatOpenAI()

# Add handler to the chain
chain = prompt | llm
chain = chain.with_config(callbacks=[handler])

response = chain.invoke({"input": "What is machine learning?"})

With Agents

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.tools import tool
from enkrypt_guardrails_handler import EnkryptGuardrailsHandler

handler = EnkryptGuardrailsHandler()

@tool
def search(query: str) -> str:
    """Search for information."""
    return f"Results for: {query}"

llm = ChatOpenAI()
tools = [search]

# Create agent with guardrails
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    callbacks=[handler]
)

result = agent_executor.invoke({"input": "Search for Python tutorials"})

With Retrievers (RAG)

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from enkrypt_guardrails_handler import EnkryptGuardrailsHandler

handler = EnkryptGuardrailsHandler()

# Create retriever
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(["Document 1", "Document 2"], embeddings)
retriever = vectorstore.as_retriever()

# Create RAG chain with guardrails
llm = ChatOpenAI()
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    callbacks=[handler]
)

result = qa_chain.invoke("What is in Document 1?")

Audit-Only Mode

# Log violations without blocking
handler = EnkryptGuardrailsHandler(
    raise_on_violation=False,  # Don't raise exceptions
    audit_only=True,           # Just log violations
)

Disable Sensitive Tool Blocking

handler = EnkryptGuardrailsHandler(
    block_sensitive_tools=False,  # Allow sensitive tools
)

LangGraph Integration

For LangGraph’s create_react_agent, use pre_model_hook and post_model_hook.

Installation

cd hooks/langgraph
pip install -r requirements.txt

Basic Usage

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from enkrypt_guardrails_hook import create_pre_model_hook, create_post_model_hook
from langgraph.prebuilt import create_react_agent

# Define your tools
@tool
def search(query: str) -> str:
    """Search for information."""
    return f"Results for {query}"

# Create model and tools
model = ChatOpenAI(model="gpt-4")
tools = [search]

# Create hooks
pre_hook = create_pre_model_hook(block_on_violation=True)
post_hook = create_post_model_hook(block_on_violation=True)

# Create agent with guardrails
agent = create_react_agent(
    model,
    tools,
    pre_model_hook=pre_hook,
    post_model_hook=post_hook,
)

# Use the agent
result = agent.invoke({"messages": [("user", "Search for LangGraph docs")]})

Convenience Functions

from enkrypt_guardrails_hook import create_protected_agent, create_audit_only_agent

# Create fully protected agent
agent = create_protected_agent(
    model,
    tools,
    block_on_violation=True,
    wrap_agent_tools=True,  # Also protect tool calls
)

# Create audit-only agent
audit_agent = create_audit_only_agent(model, tools)

Tool Wrapping

from enkrypt_guardrails_hook import wrap_tools, EnkryptToolWrapper

# Wrap multiple tools
protected_tools = wrap_tools(tools, block_on_violation=True)

# Or wrap individually
wrapper = EnkryptToolWrapper(
    my_tool,
    block_on_violation=True,
    check_inputs=True,
    check_outputs=True,
)
protected_tool = wrapper.tool

Configuration

LangChain Configuration

guardrails_config.json

{
  "enkrypt_api": {
    "url": "https://api.enkryptai.com/guardrails/policy/detect",
    "api_key": "YOUR_ENKRYPT_API_KEY",
    "ssl_verify": true,
    "timeout": 15,
    "fail_silently": true
  },
  "on_llm_start": {
    "enabled": true,
    "guardrail_name": "Sample Airline Guardrail",
    "block": ["injection_attack", "pii", "toxicity"]
  },
  "on_tool_start": {
    "enabled": true,
    "guardrail_name": "Tool Input Policy",
    "block": ["injection_attack", "pii"]
  },
  "sensitive_tools": [
    "execute_sql",
    "run_command",
    "shell_*",
    "bash",
    "delete_*",
    "write_file",
    "python_repl"
  ]
}

LangGraph Configuration

guardrails_config.json

{
  "enkrypt_api": {
    "url": "https://api.enkryptai.com/guardrails/policy/detect",
    "api_key": "YOUR_ENKRYPT_API_KEY",
    "ssl_verify": true,
    "timeout": 15,
    "fail_silently": true
  },
  "pre_model_hook": {
    "enabled": true,
    "guardrail_name": "Sample Airline Guardrail",
    "block": ["injection_attack", "pii", "toxicity", "nsfw"]
  },
  "post_model_hook": {
    "enabled": true,
    "guardrail_name": "Sample Airline Guardrail",
    "block": ["pii", "toxicity", "nsfw"]
  },
  "before_tool_call": {
    "enabled": true,
    "guardrail_name": "Sample Airline Guardrail",
    "block": ["injection_attack", "pii"]
  },
  "after_tool_call": {
    "enabled": true,
    "guardrail_name": "Sample Airline Guardrail",
    "block": ["pii"]
  }
}

Available Detectors

Detector	Description
`injection_attack`	Prompt injection attempts
`pii`	Personal Identifiable Information
`toxicity`	Toxic/harmful content
`nsfw`	Not Safe For Work content
`keyword_detector`	Banned keywords
`policy_violation`	Custom policy violations
`bias`	Biased content
`topic_detector`	Off-topic content

Logging

Logs are written to ~/langchain/guardrails_logs/ or ~/langgraph/guardrails_logs/:

on_llm_start.jsonl / pre_model_hook.jsonl - Input validation
on_llm_end.jsonl / post_model_hook.jsonl - Output validation
on_tool_start.jsonl / before_tool_call.jsonl - Tool input checks
combined_audit.jsonl - All events combined
security_alerts.jsonl - Security violations

View Logs

# View latest blocks
tail -5 ~/langchain/guardrails_logs/security_alerts.jsonl

# View tool executions
tail -10 ~/langchain/guardrails_logs/on_tool_start.jsonl

Metrics

from enkrypt_guardrails_handler import get_guardrails_metrics

# Get all metrics
metrics = get_guardrails_metrics()

# Get metrics for specific hook
llm_metrics = get_guardrails_metrics("on_llm_start")
print(f"Total calls: {llm_metrics['total_calls']}")
print(f"Blocked: {llm_metrics['blocked_calls']}")
print(f"Avg latency: {llm_metrics['avg_latency_ms']:.2f}ms")

Error Handling

from enkrypt_guardrails_handler import (
    EnkryptGuardrailsHandler,
    GuardrailsViolationError,
    SensitiveToolBlockedError,
)

handler = EnkryptGuardrailsHandler()

try:
    response = llm.invoke("malicious prompt")
except GuardrailsViolationError as e:
    print(f"Guardrails violation: {e}")
    print(f"Hook: {e.hook_name}")
    print(f"Violations: {e.violations}")
except SensitiveToolBlockedError as e:
    print(f"Sensitive tool blocked: {e.tool_name}")
    print(f"Reason: {e.reason}")

Comparison

Feature	LangChain Module	LangGraph Module
Hook Pattern	`BaseCallbackHandler`	`pre_model_hook` / `post_model_hook`
Scope	Any LangChain component	LangGraph agents only
Tool Hooks	`on_tool_start/end`	Tool wrappers
Chain Support	Yes	No (use state hooks)
Retriever Support	Yes	No
Agent Support	Yes	Yes

Use LangChain module for:

Standalone LangChain components
Chains and pipelines
RAG applications
Any non-LangGraph agent

Use LangGraph module for:

LangGraph’s create_react_agent
LangGraph workflows

Testing

cd hooks/langchain  # or hooks/langgraph
pip install pytest pytest-asyncio

# Run tests
pytest tests/ -v

Next Steps

CrewAI Integration

Protect multi-agent CrewAI systems

Configure Policies

Create custom guardrail policies

View Metrics

Monitor guardrails performance

Audit Logs

Review security events

Get Started

Core Concepts

Features

Deployment

Client Integration

Observability

Security

Guides

Documentation Index

​Overview