Metadata-Version: 2.4
Name: easy-agentic-plugin
Version: 0.1.0
Summary: A plugin framework for agents, built on LangGraph deepagents + langgraph-cli.
Keywords: agent,llm,langgraph,deepagents,plugin,langchain
Author: limenghua
Author-email: limenghua <576566385@qq.com>
License-Expression: MIT
License-File: LICENSE
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Requires-Dist: deepagents>=0.6.10
Requires-Dist: langchain-core>=1.4.7
Requires-Dist: langgraph>=1.2.5
Requires-Dist: pyyaml>=6.0
Requires-Dist: langchain-anthropic>=1.4.6 ; extra == 'all'
Requires-Dist: langchain-openai>=1.3.2 ; extra == 'all'
Requires-Dist: langgraph-cli[inmem]>=0.4.29 ; extra == 'all'
Requires-Dist: langchain-anthropic>=1.4.6 ; extra == 'anthropic'
Requires-Dist: langgraph-cli[inmem]>=0.4.29 ; extra == 'cli'
Requires-Dist: langchain-openai>=1.3.2 ; extra == 'openai'
Requires-Python: >=3.12
Project-URL: Homepage, https://github.com/easy-agentic/easy-agentic-plugin
Project-URL: Repository, https://github.com/easy-agentic/easy-agentic-plugin
Provides-Extra: all
Provides-Extra: anthropic
Provides-Extra: cli
Provides-Extra: openai
Description-Content-Type: text/markdown

# easy-agentic-plugin

An Agent-oriented **plugin framework**: it provides a unified extension-injection mechanism for agents built on top of LangGraph **deepagents** + **langgraph-cli**. Every extension (agent / tool / skill / filesystem / middleware / model, …) is wired in through plugins.

> It is **not** a business agent, and it does not implement a runtime or a serving container — those are handled by deepagents and langgraph-cli respectively.
> For the detailed positioning and design, see [doc/requirement.md](doc/requirement.md) and [doc/architecture.md](doc/architecture.md).

## Tech stack

- Python **3.12** (pinned via uv)
- Package / environment management: **uv**
- Agent runtime: **deepagents**; serving / interface: **langgraph-cli** (agent server)
- LLM direction: **Claude** (`langchain-anthropic`)

---

## Quick start

```bash
# 1. Install uv (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. Sync dependencies (install everything from uv.lock into .venv)
uv sync

# 3. Configure environment variables: copy the .env template and fill in API keys, etc.
#    (.env is git-ignored — never commit real secrets)

# 4. Start the local agent server (LangGraph Studio)
uv run langgraph dev
# Defaults to http://127.0.0.1:2024
```

---

## Using easy-agentic-plugin as a library

easy-agentic-plugin is published as an importable library. In a consumer project:

```bash
pip install easy-agentic-plugin          # core only
pip install easy-agentic-plugin[cli]     # + langgraph-cli for `langgraph dev`
pip install easy-agentic-plugin[all]     # + Anthropic/OpenAI providers + CLI
```

Point your own `langgraph.json` at the built-in global router graph:

```json
{
  "dependencies": ["."],
  "graphs": { "agent": "easy_agentic_plugin.graph:main" },
  "env": ".env"
}
```

Then drop in your own `agents/` and `plugins/` directories. Prefer to compose the graph
yourself? Use the `build_graph()` factory exported from the top-level package.

Optional extras:

| Extra | Pulls in | Use when |
| --- | --- | --- |
| `anthropic` | `langchain-anthropic` | serving Claude models |
| `openai` | `langchain-openai` | serving OpenAI models |
| `cli` | `langgraph-cli[inmem]` | running `langgraph dev` / building an image |
| `all` | all of the above | one-shot install |

---

## How uv is used

uv is a single tool that handles **Python version + virtual environment + dependencies + running**: it reads `pyproject.toml` (declared dependencies) → resolves `uv.lock` (pinned exact versions) → syncs them into `.venv`. Day to day you **do not need to activate the virtual environment manually** — just use `uv run`.

### Most-used commands

| Command | What it does | When |
| --- | --- | --- |
| `uv add <pkg>` | Add a runtime dependency (writes to pyproject and installs) | When you need a library (**don't hand-edit pyproject**) |
| `uv add --dev <pkg>` | Add a dev dependency (pytest, ruff, …) | Tooling used only for dev/test |
| `uv remove <pkg>` | Remove a dependency | When no longer needed |
| `uv run <cmd>` | Run a command inside the project env | Everything: `uv run pytest`, `uv run langgraph dev` |
| `uv sync` | Reconcile `.venv` with `uv.lock` | After pulling code / switching environments |

> 90% of the time you'll only use **`uv add`** and **`uv run`**.

### Key points

- **Dependencies are managed only through `uv add`** — don't hand-edit the `dependencies` in `pyproject.toml`; exact versions are pinned in `uv.lock` (kept under version control).
- **`uv run` implicitly syncs** the environment before executing, so after adding a dependency you can run `uv run` directly — no need to `uv sync` first.
- **No `pip install`, no `source .venv/bin/activate`** — uv prepares the environment for the subprocess automatically.
- **Python version** is pinned to 3.12 by `.python-version`; uv selects the matching interpreter automatically.

### How `uv run` works internally (in brief)

`uv run X` ≈ "ensure the environment matches the lock" + "temporarily activate `.venv`" + "run X". X ultimately resolves to an executable under `.venv/bin/` bound to this project's interpreter:

- `uv run pytest` → runs `.venv/bin/pytest` (an entry-point script generated at install time, whose shebang points at the project `.venv` python)
- `uv run python foo.py` → runs `foo.py` with `.venv/bin/python`

Handy flags: `--no-sync` (skip syncing), `--frozen` (don't re-resolve), `--locked` (require the lock to be up to date, good for CI).

---

## Common development commands

```bash
uv run langgraph dev          # Start the local agent server (entry graph: easy_agentic_plugin.graph:main)
uv run pytest                 # Run tests
uv add <pkg> / uv add --dev <pkg>   # Add dependencies
uv sync                       # Sync the environment
```

## Project documentation

- [CLAUDE.md](CLAUDE.md) — project constitution (for AI collaborators)
- [doc/](doc/) — requirements, architecture, conventions, roadmap, decision records (ADRs)

> The documents under `doc/` are kept in Chinese as the design/working record.
