---
title: "Choose an integration"
description: "Which framework integration fits your agent, what each one describes, routes and checks, and the extras to install."
source: "Guardian Agent SDK"
---
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](../guides/index.mdx) 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`](./langchain-agents.mdx), 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`](./deep-agents.mdx), 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`](./langgraph-graphs.mdx).
- **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](./plain-langchain.mdx). 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](./multiple-agents.mdx)).

## 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](../guides/run-an-agent.mdx#calls-the-sdk-cant-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](../guides/run-an-agent.mdx#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](../guides/run-an-agent.mdx#one-proxy-per-provider)).

## Install

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

```sh
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:

```sh
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.