Choose an integration

The examples in this section run against the proxy at VIPER_PROXY_URL, with the agents (planner, report-writer, researcher) and files Before you start sets up. Each integration connects to the proxy at VIPER_PROXY_URL unless you pass guardian=.

Which one

• An agent built with LangChain’s create_agent: change one import to guardian_agent.langchain.create_agent, and give the agent’s enrolled name.
• An agent built with Deep Agents’ create_deep_agent: change one import to guardian_agent.deepagents.create_deep_agent, and give the agent’s enrolled name. Its skills, memory and sub-agents are described too.
• A LangGraph graph you wire yourself, with your own nodes and routers, and MCP tools if it uses them: build it through guardian_agent.langgraph.describe_graph.
• LangChain code that isn’t a graph, such as a chain or your own loop: describe the agent with guardian.agent() and bind each chat model. This isn’t an integration: describing the agent is your code’s job, as with any model client you call yourself.

Several agents can run in one process, each signing as itself (Multiple agents).

What each one does

The three integrations describe the agent from what your framework builds: its models, tools, middleware and their settings, the graph’s nodes and edges, and the framework’s package versions. The same agent always gives the same definition, and changing anything it records gives a new one. Where they differ:

• create_agent and create_deep_agent
  • Send: the system prompt and tools they describe, since the agent’s requests are built from them.
  • Route: the agent’s model, the models LangChain’s own middleware calls, and, for Deep Agents, each sub-agent’s.
  • Check, on each call: that the model, its settings, the tools offered and the response format are the ones the definition describes. Middleware can change a call as the agent runs, so a call that doesn’t match is refused before it’s sent. Middleware that changes the prompt isn’t caught.
  • MCP tools and structured output: both supported.
• describe_graph
  • Send: whatever your nodes send, so sending the instructions you record is your code’s job.
  • Route: the models you pass in models.
  • Check, on each request: the model’s settings and the tools offered. A response format is refused, since a graph’s definition can’t describe one yet.
  • MCP tools: supported, in a ToolNode or given as tools=.
• Plain binding (guardian.agent() and bind())
  • Send: whatever your code sends, prompts and tools included.
  • Route: each chat model you bind.
  • Check, on each request: the model’s settings only.

Each integration refuses, when the agent is made, a model it finds but can’t route, such as one your own middleware, a tool or a graph node holds, since its calls would go out unsigned. None of them can see a model your code builds or looks up as the agent runs (Calls the SDK can’t see).

One provider per agent, for now

An integration connects to one proxy, and a proxy fronts one provider’s endpoint (One proxy per provider). So all of an agent’s models, its middleware’s and sub-agents’ included, must come from that provider. The SDK can’t tell which provider the proxy fronts, but it refuses an agent whose models come from more than one, such as an OpenAI agent with an Anthropic fallback model, with TypeError when it’s made, whatever exclude leaves out, since one provider’s calls would fail at the proxy. An agent that needs both providers can call their clients through a proxy for each (One proxy per provider).

Install

The integrations come with the SDK’s extras, from EQTY Lab’s Cloudsmith repository (Package managers), beside your provider’s LangChain package from PyPI. Install the extras you need, in one command:

uv add "eqty-guardian-agent[langchain,deepagents,mcp]" langchain-openai

With pip, the SDK comes from Cloudsmith only, and your provider’s package from PyPI, in two commands:

PIP_INDEX_URL="https://dl.cloudsmith.io/$VIPER_CLOUDSMITH_TOKEN/eqtylab/prod/python/simple/" \
  pip install "eqty-guardian-agent[langchain,deepagents,mcp]"
pip install langchain-openai

• langchain: create_agent, describe_graph and binding LangChain chat models. It brings langchain 1.2.11 or later, langchain-core 1.6.10 or later, and langgraph 1.1.10 or later.
• deepagents: create_deep_agent, with Deep Agents 0.7. It needs Python 3.11 or later: on Python 3.10 the extra installs nothing, and calling create_deep_agent raises ModuleNotFoundError, saying it needs Python 3.11 or later and the deepagents extra.
• mcp: tools from MCP servers, with langchain-mcp-adapters 0.3. Use it beside langchain.

Binding reaches inside LangChain’s chat models, so it’s tested with langchain-openai and langchain-anthropic 1.7. Another release may keep its client elsewhere, and binding then refuses the model rather than guess.