Metadata-Version: 2.4
Name: managed-deepagents
Version: 0.4.0.dev67
Summary: Managed Deep Agents — the define_deep_agent authoring interface plus the CLI that compiles and deploys a code-first Deep Agent repository to a managed LangGraph runtime.
Author: LangChain
License: MIT
Project-URL: Homepage, https://github.com/langchain-ai/managed-deepagents-sdk
Project-URL: Repository, https://github.com/langchain-ai/managed-deepagents-sdk
Keywords: langchain,langgraph,deepagents,agents,cli
Classifier: Programming Language :: Rust
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: test
Requires-Dist: pytest>=8; extra == "test"
Requires-Dist: pyjwt[crypto]>=2.8.0; extra == "test"
Requires-Dist: starlette>=0.37.0; extra == "test"
Dynamic: license-file

<!-- markdownlint-disable MD033 MD041 -->

<div align="center">
  <a href="https://www.langchain.com/langsmith-managed-deep-agents-waitlist">
    <img alt="Managed Deep Agents logo" src="https://raw.githubusercontent.com/langchain-ai/managed-deepagents-sdk/main/.github/assets/logo.png" width="70%">
  </a>
</div>

<div align="center">
  <h3>Python authoring package and CLI launcher for Managed Deep Agents.</h3>
</div>

> [!IMPORTANT]
> **Active development / private beta.** Managed Deep Agents is in active
> development and currently in private beta. The PyPI package API and managed
> runtime contract may change. [Join the
> waitlist](https://www.langchain.com/langsmith-managed-deep-agents-waitlist)
> for access and updates.

`managed-deepagents` is the PyPI package for authoring Managed Deep Agents in
Python. It includes:

- `define_deep_agent`, the Python authoring contract for managed agents.
- `define_schedule`, the Python contract for managed cron schedules.
- `mda`, the CLI used to build and deploy your agent to LangSmith.
- `managed_deepagents.runtime`, the runtime helper used by generated managed
  entry modules.

## Install

```bash
uv tool install managed-deepagents
```

> [!NOTE]
> **Private beta: dev releases only.** We currently publish only PEP 440
> pre-release (dev) versions and no stable version yet. uv skips pre-releases
> by default unless they are allowed explicitly:
>
> ```bash
> uv tool install --prerelease allow managed-deepagents
> ```

This package requires Python 3.9 or newer. Each platform wheel bundles the
prebuilt `mda` binary for its OS and CPU architecture and exposes it through the
`mda` console script. This PyPI-installed CLI scaffolds and compiles Python
projects only and vendors the Python runtime bundled with this wheel.

To start a new project:

```bash
mda init my-agent
cd my-agent
uv sync
```

## Define an Agent

Create an `agent.py` that defines an `agent`:

```python
from managed_deepagents import define_deep_agent

# The system prompt comes from instructions.md next to this file.
agent = define_deep_agent(
    model="openai:gpt-5.5",
    tools=[query_db],
)
```

`define_deep_agent` accepts the [`create_deep_agent`](https://reference.langchain.com/python/deepagents/graph/create_deep_agent) keyword surface minus the managed keys: `backend`, `store`, `checkpointer`, `memory`, `skills`, and `system_prompt`. Those are provided by the managed runtime when your agent is deployed. Write the system prompt in `instructions.md` next to `agent.py`; the CLI embeds it at deploy time.

On deploy, Context Hub stores durable agent memory under `memories/**`. Hot memory (`memories/AGENTS.md`) is always injected into the prompt; other files under `memories/**` are cold artefacts the agent can create and read on demand. Deploy never overwrites Hub memories.

## Project Shape

```text
my-agent/
  agent.py              # named `agent` variable
  instructions.md       # managed system prompt
  pyproject.toml
  .env                  # local deploy secrets, never committed
  schedules/            # optional managed cron schedules
  tools/                # optional custom tools
  middleware/           # optional middleware
  skills/               # optional skills synced to Context Hub
  sandbox/              # LangSmith sandbox (`mda init` includes this; delete to opt out)
  connectors/mcp.py     # optional MCP server declaration
```

The CLI copies your project files into the managed build and generates the entry
module that connects your definition to the hosted runtime.

The agent entry must live at the project root as `agent.py`.

## Define a Schedule

Create one file per schedule under `schedules/` and define a named `schedule`:

```python
# schedules/daily_digest.py
from managed_deepagents import define_schedule

schedule = define_schedule(
    cron="0 8 * * 1-5",
    timezone="America/Los_Angeles",
    prompt="Write the daily digest.",
)
```

`mda deploy` reconciles schedules as LangSmith cron jobs after the deployment is
live. Declarations must be statically serializable literals or top-level
constants; prompt schedules become user-message input, and stateless runs clean
up their temporary thread after completion.

## Sandbox

`mda init` scaffolds `sandbox/__init__.py` with a LangSmith sandbox. MDA only
enables the sandbox when that declaration is present — delete `sandbox/` to opt
out:

```python
from deepagents.backends import LangSmithSandbox
from managed_deepagents import define_sandbox

sandbox = define_sandbox(
    LangSmithSandbox,
    scope="thread",
    idle_ttl_seconds=600,
)
```

If `sandbox/setup.sh` exists, MDA embeds it and runs it once when the sandbox is
first provisioned. MDA owns sandbox naming, image/snapshot selection, reuse, and
lifecycle.

## MCP Connectors

Add `connectors/mcp.py` to attach MCP servers. The file must define a named
`mcp` declaration. By default, MDA exposes every tool loaded from each declared
server:

```python
from managed_deepagents.connectors import define_mcp_servers

mcp = define_mcp_servers(
    mcp_servers={
        "langchainDocs": {
            "transport": "http",
            "url": "https://docs.langchain.com/mcp",
            "include_tools": ["search", "fetch"],
        },
    },
)
```

Use `include_tools` or `exclude_tools` inside a server config to select a
subset. Tool names are raw MCP tool names before the managed `{server}__` prefix
is applied, so `"include_tools": ["search"]` on server `langchainDocs` exposes
`langchainDocs__search` when prefixing is enabled.

## CLI

Create a new project:

```bash
mda init my-agent
```

Build locally:

```bash
mda build ./my-agent
```

Run on the local LangGraph dev server:

```bash
mda dev ./my-agent
```

`mda dev` requires `uv` on `PATH`, but it resolves the local LangGraph dev
server automatically; you do not need to install a global `langgraph` command.

Deploy to LangSmith:

```bash
mda deploy ./my-agent
```

The generated build is written to `<root>/.mda/build` by default.

Common deploy options:

```bash
mda deploy ./my-agent --name my-agent-dev --deployment-type dev
mda deploy ./my-agent --tenant-id "$LANGSMITH_TENANT_ID"
mda deploy ./my-agent --no-wait
```

Before deploying, make sure `LANGSMITH_API_KEY` and your model provider key
such as `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` are available in the project
`.env`, the process environment, or LangSmith workspace secrets. Use
`LANGSMITH_TENANT_ID` or `--tenant-id` when your LangSmith API key requires a
workspace/tenant selection.
