agent-weave-lib 0.1.0__tar.gz

agent_weave_lib-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+venv/
+.env
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.so
+.coverage
+htmlcov/

agent_weave_lib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Soham Dahivalkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_weave_lib-0.1.0/PKG-INFO

@@ -0,0 +1,296 @@
+Metadata-Version: 2.4
+Name: agent-weave-lib
+Version: 0.1.0
+Summary: Lightweight AI agent framework with tool use, ReAct reasoning, multi-agent teams, and memory.
+Project-URL: Homepage, https://github.com/sohammmmm10/agent-weave
+Project-URL: Repository, https://github.com/sohammmmm10/agent-weave
+Project-URL: Issues, https://github.com/sohammmmm10/agent-weave/issues
+Author: Soham Dahivalkar
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,framework,llm,multi-agent,react,tool-use
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: typing-extensions>=4.8; python_version < '3.11'
+Provides-Extra: all
+Requires-Dist: ai-bridge-kit>=0.1.0; extra == 'all'
+Requires-Dist: anthropic>=0.34.0; extra == 'all'
+Requires-Dist: openai>=1.56.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.34.0; extra == 'anthropic'
+Provides-Extra: bridge
+Requires-Dist: ai-bridge-kit>=0.1.0; extra == 'bridge'
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: twine>=5.1.1; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.56.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# agent-weave
+
+`agent-weave` is a lightweight Python framework for building AI agents with tool use, ReAct reasoning, multi-agent teams, memory, and guardrails.
+
+No bloat. No magic. Just clean, composable building blocks.
+
+## Features
+
+- **`@tool` decorator** — Turn any Python function into an agent tool with auto-generated schemas.
+- **ReAct loop** — Built-in Reasoning + Acting engine with configurable iteration limits.
+- **Multi-agent teams** — Sequential pipelines, round-robin, and router-based orchestration.
+- **Memory** — Conversation memory and sliding-window memory with system prompt preservation.
+- **Guardrails** — PII detection, blocked words, regex filters, token budgets, and max-length checks.
+- **Provider backends** — OpenAI, Anthropic, and any OpenAI-compatible API.
+- **Async-first** — Full `async/await` support for every operation.
+- **CLI** — Run agents and chat from the terminal.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+With OpenAI support:
+
+```bash
+pip install -e ".[openai]"
+```
+
+With Anthropic support:
+
+```bash
+pip install -e ".[anthropic]"
+```
+
+Install everything:
+
+```bash
+pip install -e ".[all]"
+```
+
+For development:
+
+```bash
+pip install -e ".[dev,all]"
+```
+
+## Quick Start
+
+```python
+import os
+from agent_weave import Agent, tool
+from agent_weave.llm.openai_backend import OpenAIBackend
+
+@tool(description="Get the weather for a city")
+def get_weather(city: str) -> str:
+    return f"72°F and sunny in {city}"
+
+@tool(description="Calculate a math expression")
+def calculator(expression: str) -> str:
+    return str(eval(expression))
+
+agent = Agent(
+    name="assistant",
+    llm=OpenAIBackend(api_key=os.environ["OPENAI_API_KEY"]),
+    tools=[get_weather, calculator],
+    system_prompt="You are a helpful assistant. Use tools when needed.",
+)
+
+result = agent.run("What's the weather in NYC and what is 42 * 17?")
+print(result.output)
+print(f"Steps: {result.total_iterations}, Tokens: {result.total_tokens:,}")
+```
+
+## The `@tool` Decorator
+
+Turn any function into a tool. Schemas are auto-generated from type hints:
+
+```python
+from agent_weave import tool
+
+@tool(description="Search the web for a query")
+def web_search(query: str, max_results: int = 5) -> str:
+    return f"Results for: {query} (limit {max_results})"
+
+# Access the generated schema
+print(web_search.schema.to_openai_tool())
+```
+
+## Multi-Agent Teams
+
+Chain agents in a pipeline, round-robin, or route to specialists:
+
+```python
+from agent_weave import Agent, Team, Strategy
+from agent_weave.llm.openai_backend import OpenAIBackend
+
+backend = OpenAIBackend(api_key=os.environ["OPENAI_API_KEY"])
+
+researcher = Agent(name="researcher", llm=backend,
+    system_prompt="Research the topic. Provide key facts.")
+
+writer = Agent(name="writer", llm=backend,
+    system_prompt="Write a blog post from the research provided.")
+
+editor = Agent(name="editor", llm=backend,
+    system_prompt="Polish and improve the writing.")
+
+# Sequential: researcher -> writer -> editor
+team = Team(
+    agents=[researcher, writer, editor],
+    strategy=Strategy.SEQUENTIAL,
+)
+result = team.run("AI agents in 2025")
+print(result.final_output)
+```
+
+### Router Strategy
+
+```python
+router = Agent(name="router", llm=backend,
+    system_prompt="You route tasks to the right specialist.")
+
+team = Team(
+    agents=[researcher, writer],
+    strategy=Strategy.ROUTER,
+    router=router,
+)
+result = team.run("Write a poem about AI")
+```
+
+## Memory
+
+```python
+from agent_weave.memory import ConversationMemory, SlidingWindowMemory
+
+# Unlimited memory
+agent = Agent(name="bot", llm=backend, memory=ConversationMemory())
+
+# Fixed window (keeps last 20 messages + system prompt)
+agent = Agent(name="bot", llm=backend,
+    memory=SlidingWindowMemory(max_messages=20))
+```
+
+## Guardrails
+
+```python
+from agent_weave import (
+    Agent, MaxLengthGuardrail, PIIGuardrail, BlockedWordsGuardrail,
+)
+
+agent = Agent(
+    name="safe-bot",
+    llm=backend,
+    token_budget=10_000,  # Max 10k tokens per run
+    output_guardrails=[
+        MaxLengthGuardrail(max_chars=5_000),
+        PIIGuardrail(redact=True),
+        BlockedWordsGuardrail(words=["confidential", "password"]),
+    ],
+)
+```
+
+## Conversational Chat
+
+```python
+agent = Agent(name="chatbot", llm=backend,
+    system_prompt="You are a friendly chatbot.")
+
+# chat() preserves history across calls
+agent.chat("Hello!")
+agent.chat("What did I just say?")  # Agent remembers
+agent.reset()  # Clear conversation
+```
+
+## Async Support
+
+```python
+import asyncio
+
+async def main():
+    result = await agent.arun("Summarize AI trends")
+    print(result.output)
+
+asyncio.run(main())
+```
+
+## Anthropic Backend
+
+```python
+from agent_weave.llm.anthropic_backend import AnthropicBackend
+
+agent = Agent(
+    name="claude-agent",
+    llm=AnthropicBackend(api_key=os.environ["ANTHROPIC_API_KEY"]),
+    system_prompt="You are helpful.",
+)
+result = agent.run("Explain quantum computing simply.")
+```
+
+## CLI
+
+```bash
+# Set your API key
+export OPENAI_API_KEY="sk-..."
+
+# Run a single task
+agent-weave run "What are the top 3 AI trends in 2025?"
+
+# Interactive chat
+agent-weave chat
+
+# Library info
+agent-weave info
+```
+
+## Run Tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest
+```
+
+## Project Structure
+
+```
+agent-weave/
+├── src/agent_weave/
+│   ├── __init__.py          # Public API
+│   ├── agent.py             # Core Agent class
+│   ├── tool.py              # @tool decorator & Tool class
+│   ├── react.py             # ReAct reasoning engine
+│   ├── team.py              # Multi-agent orchestration
+│   ├── guardrails.py        # Safety & validation
+│   ├── config.py            # Settings
+│   ├── models.py            # Data models
+│   ├── errors.py            # Custom exceptions
+│   ├── cli.py               # CLI interface
+│   ├── memory/
+│   │   ├── base.py          # Memory interface
+│   │   └── conversation.py  # Memory implementations
+│   └── llm/
+│       ├── base.py          # LLM backend interface
+│       ├── openai_backend.py
+│       └── anthropic_backend.py
+├── tests/
+├── examples/
+├── pyproject.toml
+└── README.md
+```
+
+## License
+
+MIT

agent_weave_lib-0.1.0/README.md

@@ -0,0 +1,254 @@
+# agent-weave
+
+`agent-weave` is a lightweight Python framework for building AI agents with tool use, ReAct reasoning, multi-agent teams, memory, and guardrails.
+
+No bloat. No magic. Just clean, composable building blocks.
+
+## Features
+
+- **`@tool` decorator** — Turn any Python function into an agent tool with auto-generated schemas.
+- **ReAct loop** — Built-in Reasoning + Acting engine with configurable iteration limits.
+- **Multi-agent teams** — Sequential pipelines, round-robin, and router-based orchestration.
+- **Memory** — Conversation memory and sliding-window memory with system prompt preservation.
+- **Guardrails** — PII detection, blocked words, regex filters, token budgets, and max-length checks.
+- **Provider backends** — OpenAI, Anthropic, and any OpenAI-compatible API.
+- **Async-first** — Full `async/await` support for every operation.
+- **CLI** — Run agents and chat from the terminal.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+With OpenAI support:
+
+```bash
+pip install -e ".[openai]"
+```
+
+With Anthropic support:
+
+```bash
+pip install -e ".[anthropic]"
+```
+
+Install everything:
+
+```bash
+pip install -e ".[all]"
+```
+
+For development:
+
+```bash
+pip install -e ".[dev,all]"
+```
+
+## Quick Start
+
+```python
+import os
+from agent_weave import Agent, tool
+from agent_weave.llm.openai_backend import OpenAIBackend
+
+@tool(description="Get the weather for a city")
+def get_weather(city: str) -> str:
+    return f"72°F and sunny in {city}"
+
+@tool(description="Calculate a math expression")
+def calculator(expression: str) -> str:
+    return str(eval(expression))
+
+agent = Agent(
+    name="assistant",
+    llm=OpenAIBackend(api_key=os.environ["OPENAI_API_KEY"]),
+    tools=[get_weather, calculator],
+    system_prompt="You are a helpful assistant. Use tools when needed.",
+)
+
+result = agent.run("What's the weather in NYC and what is 42 * 17?")
+print(result.output)
+print(f"Steps: {result.total_iterations}, Tokens: {result.total_tokens:,}")
+```
+
+## The `@tool` Decorator
+
+Turn any function into a tool. Schemas are auto-generated from type hints:
+
+```python
+from agent_weave import tool
+
+@tool(description="Search the web for a query")
+def web_search(query: str, max_results: int = 5) -> str:
+    return f"Results for: {query} (limit {max_results})"
+
+# Access the generated schema
+print(web_search.schema.to_openai_tool())
+```
+
+## Multi-Agent Teams
+
+Chain agents in a pipeline, round-robin, or route to specialists:
+
+```python
+from agent_weave import Agent, Team, Strategy
+from agent_weave.llm.openai_backend import OpenAIBackend
+
+backend = OpenAIBackend(api_key=os.environ["OPENAI_API_KEY"])
+
+researcher = Agent(name="researcher", llm=backend,
+    system_prompt="Research the topic. Provide key facts.")
+
+writer = Agent(name="writer", llm=backend,
+    system_prompt="Write a blog post from the research provided.")
+
+editor = Agent(name="editor", llm=backend,
+    system_prompt="Polish and improve the writing.")
+
+# Sequential: researcher -> writer -> editor
+team = Team(
+    agents=[researcher, writer, editor],
+    strategy=Strategy.SEQUENTIAL,
+)
+result = team.run("AI agents in 2025")
+print(result.final_output)
+```
+
+### Router Strategy
+
+```python
+router = Agent(name="router", llm=backend,
+    system_prompt="You route tasks to the right specialist.")
+
+team = Team(
+    agents=[researcher, writer],
+    strategy=Strategy.ROUTER,
+    router=router,
+)
+result = team.run("Write a poem about AI")
+```
+
+## Memory
+
+```python
+from agent_weave.memory import ConversationMemory, SlidingWindowMemory
+
+# Unlimited memory
+agent = Agent(name="bot", llm=backend, memory=ConversationMemory())
+
+# Fixed window (keeps last 20 messages + system prompt)
+agent = Agent(name="bot", llm=backend,
+    memory=SlidingWindowMemory(max_messages=20))
+```
+
+## Guardrails
+
+```python
+from agent_weave import (
+    Agent, MaxLengthGuardrail, PIIGuardrail, BlockedWordsGuardrail,
+)
+
+agent = Agent(
+    name="safe-bot",
+    llm=backend,
+    token_budget=10_000,  # Max 10k tokens per run
+    output_guardrails=[
+        MaxLengthGuardrail(max_chars=5_000),
+        PIIGuardrail(redact=True),
+        BlockedWordsGuardrail(words=["confidential", "password"]),
+    ],
+)
+```
+
+## Conversational Chat
+
+```python
+agent = Agent(name="chatbot", llm=backend,
+    system_prompt="You are a friendly chatbot.")
+
+# chat() preserves history across calls
+agent.chat("Hello!")
+agent.chat("What did I just say?")  # Agent remembers
+agent.reset()  # Clear conversation
+```
+
+## Async Support
+
+```python
+import asyncio
+
+async def main():
+    result = await agent.arun("Summarize AI trends")
+    print(result.output)
+
+asyncio.run(main())
+```
+
+## Anthropic Backend
+
+```python
+from agent_weave.llm.anthropic_backend import AnthropicBackend
+
+agent = Agent(
+    name="claude-agent",
+    llm=AnthropicBackend(api_key=os.environ["ANTHROPIC_API_KEY"]),
+    system_prompt="You are helpful.",
+)
+result = agent.run("Explain quantum computing simply.")
+```
+
+## CLI
+
+```bash
+# Set your API key
+export OPENAI_API_KEY="sk-..."
+
+# Run a single task
+agent-weave run "What are the top 3 AI trends in 2025?"
+
+# Interactive chat
+agent-weave chat
+
+# Library info
+agent-weave info
+```
+
+## Run Tests
+
+```bash
+pip install -e ".[dev]"
+python -m pytest
+```
+
+## Project Structure
+
+```
+agent-weave/
+├── src/agent_weave/
+│   ├── __init__.py          # Public API
+│   ├── agent.py             # Core Agent class
+│   ├── tool.py              # @tool decorator & Tool class
+│   ├── react.py             # ReAct reasoning engine
+│   ├── team.py              # Multi-agent orchestration
+│   ├── guardrails.py        # Safety & validation
+│   ├── config.py            # Settings
+│   ├── models.py            # Data models
+│   ├── errors.py            # Custom exceptions
+│   ├── cli.py               # CLI interface
+│   ├── memory/
+│   │   ├── base.py          # Memory interface
+│   │   └── conversation.py  # Memory implementations
+│   └── llm/
+│       ├── base.py          # LLM backend interface
+│       ├── openai_backend.py
+│       └── anthropic_backend.py
+├── tests/
+├── examples/
+├── pyproject.toml
+└── README.md
+```
+
+## License
+
+MIT

agent_weave_lib-0.1.0/examples/custom_tools.py

@@ -0,0 +1,86 @@
+"""Advanced tools and guardrails example for agent-weave."""
+
+import json
+import os
+
+from agent_weave import (
+    Agent,
+    BlockedWordsGuardrail,
+    MaxLengthGuardrail,
+    PIIGuardrail,
+    tool,
+)
+from agent_weave.llm.openai_backend import OpenAIBackend
+
+# --- Custom tools ---
+
+
+@tool(description="Search a knowledge base for information about a topic")
+def knowledge_search(query: str) -> str:
+    """Simulated knowledge base search."""
+    kb = {
+        "python": "Python is a high-level programming language known for simplicity.",
+        "rust": "Rust is a systems language focused on safety and performance.",
+        "agents": "AI agents are autonomous systems that can reason and use tools.",
+        "rag": "RAG combines retrieval with generation for grounded AI responses.",
+    }
+    results = []
+    for key, value in kb.items():
+        if key in query.lower():
+            results.append(value)
+    return "\n".join(results) if results else "No results found."
+
+
+@tool(
+    name="create_summary",
+    description="Create a structured JSON summary from text",
+)
+def create_summary(text: str, max_points: int = 3) -> str:
+    """Create a bullet-point summary."""
+    sentences = [s.strip() for s in text.split(".") if s.strip()]
+    points = sentences[:max_points]
+    return json.dumps({"summary_points": points, "total_sentences": len(sentences)})
+
+
+@tool(description="Get the current date and time")
+def get_current_time() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).isoformat()
+
+
+# --- Agent with guardrails ---
+
+
+def main() -> None:
+    backend = OpenAIBackend(
+        api_key=os.environ["OPENAI_API_KEY"],
+        default_model="gpt-4o-mini",
+    )
+
+    agent = Agent(
+        name="safe-researcher",
+        llm=backend,
+        tools=[knowledge_search, create_summary, get_current_time],
+        system_prompt=(
+            "You are a research assistant with access to a knowledge base. "
+            "Always search before answering. Provide factual, concise answers."
+        ),
+        max_iterations=8,
+        token_budget=10_000,
+        output_guardrails=[
+            MaxLengthGuardrail(max_chars=5_000),
+            PIIGuardrail(redact=True),
+            BlockedWordsGuardrail(words=["confidential", "secret"]),
+        ],
+        verbose=True,
+    )
+
+    result = agent.run("What can you tell me about Python and AI agents?")
+    print(f"\nAnswer: {result.output}")
+    print(f"\nSteps: {result.total_iterations}")
+    print(f"Tokens: {result.total_tokens:,}")
+    print(f"Tool calls: {result.total_tool_calls}")
+
+
+if __name__ == "__main__":
+    main()