Metadata-Version: 2.4
Name: weaveflow
Version: 1.1.1
Summary: Weave: composable AI agents with a universal interface. Connect any framework (LangChain, CrewAI, or any Python callable) with no rewrite.
Project-URL: Homepage, https://github.com/TheDeveloperDoctor/weave
Project-URL: Repository, https://github.com/TheDeveloperDoctor/weave
Project-URL: Issues, https://github.com/TheDeveloperDoctor/weave/issues
Project-URL: Changelog, https://github.com/TheDeveloperDoctor/weave/blob/main/CHANGELOG.md
Author-email: Haris Ahmed <harisahmed510.00@gmail.com>
License: Apache-2.0
License-File: LICENSE
Keywords: agents,ai,crewai,framework,interoperability,langchain,llm
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
Requires-Python: >=3.10
Provides-Extra: all
Requires-Dist: anthropic>=0.39; extra == 'all'
Requires-Dist: google-generativeai>=0.8; extra == 'all'
Requires-Dist: openai>=1.0; extra == 'all'
Provides-Extra: anthropic
Requires-Dist: anthropic>=0.39; extra == 'anthropic'
Provides-Extra: deepseek
Requires-Dist: openai>=1.0; extra == 'deepseek'
Provides-Extra: dev
Requires-Dist: mypy>=1.11; extra == 'dev'
Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
Requires-Dist: pytest-cov>=5.0; extra == 'dev'
Requires-Dist: pytest>=8.0; extra == 'dev'
Requires-Dist: ruff>=0.6; extra == 'dev'
Provides-Extra: docs
Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
Provides-Extra: google
Requires-Dist: google-generativeai>=0.8; extra == 'google'
Provides-Extra: mistral
Requires-Dist: openai>=1.0; extra == 'mistral'
Provides-Extra: ollama
Requires-Dist: openai>=1.0; extra == 'ollama'
Provides-Extra: openai
Requires-Dist: openai>=1.0; extra == 'openai'
Description-Content-Type: text/markdown

# Weave: composable AI agent framework

> USB for AI agents. Build an agent once against an open contract, and connect it to
> any other compliant agent, regardless of LLM, language, or host.

Weave is a Python framework for building **composable** AI agents. Every agent exposes
typed **input/output ports** and **capability tags** as its public interface; its
brain (LLM), memory, and tools stay private. Any agent's output can plug into any
compatible agent's input, and when types are compatible but not identical, Weave
auto-injects a transform.

```python
from weave import agent, DataType, Pipeline

@agent(name="summarizer", input=DataType.TEXT, output=DataType.TEXT,
       tags=["summarization"], llm="anthropic:claude-opus-4-8")
async def summarize(ctx):
    return await ctx.complete(f"Summarize:\n{ctx.input.value}")

result = await Pipeline([summarize]).run("a long document ...")
```

## Why Weave

| Problem today | Weave |
|---|---|
| Agents are locked to one framework | Open port contract; any compliant agent connects |
| LLM vendor lock-in | Swap brains via a `"provider:model"` string |
| Custom glue code between agents | Connection protocol validates + auto-transforms handoffs |
| Hard to test multi-agent chains | In-process `LocalRunner` with per-hop tracing |

## Install

```bash
make install                       # dev + all providers in a venv
# or, minimal core (zero deps) + one provider:
pip install "weaveflow[anthropic]"
```

The core has **no runtime dependencies**. Provider SDKs are optional extras:
`weaveflow[openai]`, `weaveflow[anthropic]`, `weaveflow[google]`, `weaveflow[mistral]`, `weaveflow[ollama]`, `weaveflow[deepseek]`, `weaveflow[all]`.

## Core concepts

Weave models an agent as a body with a standard anatomy (PRD §5.3):

| Layer | Weave component |
|---|---|
| **Skin** (ports) | `PortSchema`, the `input`/`output` typed contracts |
| **Brain** (LLM) | `LLMAdapter`, swappable via `create_adapter("provider:model")` |
| **Memory** | `ShortTermMemory`, `LongTermMemory` (vector search) |
| **Nervous system** | `Guardrails`: `pre` / `post` / `on_error` hooks |
| **Connection** | `ConnectionProtocol` + `Router` + transforms |

### Standard data types

`text`, `structured_json`, `image`, `code`, `audio`, `document`, `embedding`, `stream`.

### Two ways to define an agent

```python
# 1. Decorator (ergonomic)
@agent(name="x", input=DataType.TEXT, output=DataType.TEXT, llm="openai:gpt-4o")
async def x(ctx): ...

# 2. Subclass BaseAgent (full control / DI)
class MyAgent(BaseAgent):
    async def handle(self, ctx): ...
```

### Swap LLM backends

```python
"openai:gpt-4o" · "anthropic:claude-opus-4-8" · "google:gemini-1.5-pro"
"mistral:mistral-large-latest" · "deepseek:deepseek-chat" · "ollama:llama3"
```

Set the matching API key env var (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, …). Ollama
runs locally and needs none.

### Compose and connect

```python
from weave import Pipeline, Parallel, LocalRunner

# Series:
pipe = Pipeline([cleaner, extractor, summarizer], llm="anthropic:claude-opus-4-8")
out = await pipe.run("raw input")

# Fan-out / fan-in (runs branches concurrently, then merges):
fan = Parallel([sentiment, topics, summary], input=DataType.TEXT)

# Any variant: Parallel is a BaseAgent, so it nests inside a Pipeline:
pipe = Pipeline([cleaner, Parallel([analyze_a, analyze_b]), report])

trace = await LocalRunner().simulate([cleaner, extractor], "raw input")
for hop in trace.hops:
    print(hop.agent, hop.output.value, hop.elapsed_ms)
```

### Connect a foreign agent, no rewrite

**If you can call it from Python, you can connect it to Weave.** Already have an agent in
LangChain, LangGraph, or CrewAI? Wrap it and plug it in, and the handoff auto-calibrates.
Anything else (a plain function, a bound method, an HTTP or SDK call) goes through
`from_callable`, the universal escape hatch. The bridges are duck-typed, so the
zero-dependency core stays clean, and a wrapped agent becomes a `BaseAgent` that composes
in `Pipeline` and `Parallel` exactly like a native one.

```python
from weave import from_langchain, from_crewai, from_callable, Pipeline

theirs = from_langchain(their_langchain_chain)   # also works with LangGraph graphs
mine   = my_weave_agent
out = await Pipeline([theirs, mine]).run("...")   # connected, no rebuild

# or any function / SDK call:
agent = from_callable(lambda text: external_sdk.run(text), name="legacy")
```

See [docs/guide-interop.md](docs/guide-interop.md).

## CLI

```bash
weave scaffold my-agent           # create a starter agent file
weave validate my_agent.py        # validate ports + print manifest
weave package my_agent.py         # portable .weave.zip (code + manifest.json)
```

## Project layout

```
weave/
  types/        # 8 primitive data types + compatibility graph
  schema/       # port schemas, validator, registry
  llm/          # adapter abstraction + 6 providers + factory
  memory/       # short-term buffer + long-term vector store
  guardrails/   # pre/post/on-error hooks
  agent/        # BaseAgent, context, @agent decorator
  connection/   # protocol engine, router, transforms
  interop/      # bridges: from_langchain / from_crewai / from_callable
  runtime/      # Pipeline (series) + Parallel (fan-out/in) + LocalRunner
  cli/          # scaffold / validate / package
tests/          # mirrors weave/ one-to-one
examples/       # offline quickstart
example-agents/ # copy-paste agent templates (one per folder) + a connect demo
```

## Development

```bash
make check      # lint + typecheck + tests (≥80% coverage gate)
make example    # run the offline quickstart
make docker-build
```

## License

Apache-2.0.
