agentu 1.0.0__tar.gz

agentu-1.0.0/.github/workflows/python-package.yml

@@ -0,0 +1,57 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}

agentu-1.0.0/.gitignore

@@ -0,0 +1,15 @@
+dist
+llm-task-log.md
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.db
+*.sqlite
+*.sqlite3
+.pytest_cache/
+.coverage
+htmlcov/
+*.egg-info/
+build/
+.DS_Store

agentu-1.0.0/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-01-09
+
+### Added
+- **Workflow system** with operator-based composition (`>>` for sequential, `&` for parallel)
+- `Agent.__call__()` method to create workflow steps with clean syntax
+- Comprehensive workflow tests (18 new tests)
+- `workflow.py` module with `Step`, `SequentialStep`, and `ParallelStep` classes
+- Automatic context passing between workflow steps
+- Lambda support for precise data flow control in workflows
+- New workflow examples (`examples/workflow.py`, `examples/orchestrator.py`)
+
+### Changed
+- **BREAKING**: Removed `Orchestrator`, `ExecutionMode`, `Task`, and `Message` classes
+- **BREAKING**: Removed `add_tool()`, `add_tools()`, `add_agent()`, `add_agents()` methods
+- **BREAKING**: Removed `execute_tool()` and `process_input()` (use `call()` and `infer()`)
+- Simplified API: `with_tools()` and `with_agents()` now always require lists
+- Updated all examples to use new workflow operators
+- Simplified README with real-world automated code review example
+- Updated MCP implementation to use `with_mcp()` method
+- Changed tagline to "The sleekest way to build AI agents"
+- Updated default model examples from `llama3` to `qwen3`
+
+### Removed
+- Orchestrator-based multi-agent system (replaced by workflow operators)
+- Task class for simple use cases (still available for advanced scenarios)
+- Backward compatibility aliases
+- `SERVING.md` (documentation consolidated into README)
+- Redundant example files
+
+### Fixed
+- MCP configuration to use correct `type` parameter instead of `auth_type`
+- Agent initialization to use `with_mcp()` instead of removed `load_mcp_tools()`
+- All orchestrator references updated to use `infer()` instead of `process_input()`
+- Test compatibility with new workflow system
+
+## [0.3.0] - Previous release
+
+Initial release with basic agent functionality, tools, memory, and orchestration.

agentu-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hemanth HM <hemanth.hm@gmail.com>
+
+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.

agentu-1.0.0/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: agentu
+Version: 1.0.0
+Summary: A flexible Python package for creating AI agents with customizable tools
+Author-email: Hemanth HM <hemanth.hm@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Hemanth HM <hemanth.hm@gmail.com>
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/hemanth/agentu
+Project-URL: Bug Tracker, https://github.com/hemanth/agentu/issues
+Keywords: ai,agents,openai,llm,tools
+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.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: duckduckgo-search>=4.1.1
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.23.0
+Requires-Dist: pydantic>=2.0.0
+Dynamic: license-file
+
+# AgentU
+
+**The sleekest way to build AI agents.**
+
+```bash
+pip install agentu
+```
+
+## Why AgentU?
+
+```python
+# This is all you need:
+from agentu import Agent
+
+def search_products(query: str) -> list:
+    return db.products.search(query)
+
+agent = Agent("sales").with_tools([search_products])
+
+# Direct execution
+result = await agent.call("search_products", {"query": "laptop"})
+
+# Natural language (LLM figures out the tool + params)
+result = await agent.infer("Find me laptops under $1500")
+```
+
+## Workflows in 3 Lines
+
+```python
+# Sequential: researcher → analyst → writer
+workflow = researcher("Find AI trends") >> analyst("Analyze") >> writer("Summarize")
+
+# Parallel: run 3 searches concurrently
+workflow = search("AI") & search("ML") & search("Crypto")
+
+# Combined: parallel then merge
+workflow = (search("AI") & search("ML") & search("Crypto")) >> analyst("Compare")
+
+result = await workflow.run()
+```
+
+**`>>` chains steps. `&` runs in parallel.** That's the entire API.
+
+## Memory
+
+```python
+agent.remember("Customer prefers email", importance=0.9)
+memories = agent.recall(query="email")
+```
+
+Stored in SQLite. Searchable. Persistent.
+
+## REST API
+
+```python
+from agentu import serve
+
+serve(agent, port=8000)
+# curl -X POST localhost:8000/execute -d '{"tool_name": "search_products", ...}'
+```
+
+Auto-generated Swagger docs at `/docs`.
+
+## Real-World Example: Automated Code Review
+
+```python
+import asyncio
+from agentu import Agent
+
+def get_pr_diff(pr_number: int) -> str:
+    """Fetch PR changes from GitHub."""
+    # GitHub API integration
+    return "diff --git a/src/auth.py... +added_line -removed_line"
+
+def run_tests(branch: str) -> dict:
+    """Run test suite."""
+    return {"passed": 47, "failed": 2, "coverage": 94.2}
+
+def post_comment(pr_number: int, comment: str) -> bool:
+    """Post review comment to GitHub."""
+    return True
+
+async def main():
+    # Setup agents
+    reviewer = Agent("reviewer", model="gpt-4").with_tools([get_pr_diff])
+    tester = Agent("tester").with_tools([run_tests])
+    commenter = Agent("commenter").with_tools([post_comment])
+
+    # Parallel: review code + run tests
+    workflow = reviewer("Review PR #247") & tester("Run tests on PR #247")
+    code_review, test_results = await workflow.run()
+
+    # Natural language: synthesize findings
+    summary = await commenter.infer(
+        f"Create a review comment for PR #247. "
+        f"Code review: {code_review}. Tests: {test_results}. "
+        f"Be constructive and specific."
+    )
+
+    # Post to GitHub
+    await commenter.call("post_comment", {"pr_number": 247, "comment": summary})
+    print("✓ Review posted to PR #247")
+
+asyncio.run(main())
+```
+
+**What this does:**
+- Reviews code and runs tests **in parallel** (saves time)
+- Uses `infer()` to write **human-quality review comments**
+- Posts directly to GitHub
+- **Zero manual work** - runs on every PR
+
+## Advanced: Lambda Control
+
+Need precise data flow? Use lambdas:
+
+```python
+workflow = (
+    researcher("Find companies")
+    >> analyst(lambda prev: f"Extract top 5 from: {prev['result']}")
+    >> writer(lambda prev: f"Write report about: {prev['companies']}")
+)
+```
+
+## LLM Support
+
+Works with any OpenAI-compatible API:
+
+```python
+# Ollama (default)
+Agent("assistant", model="qwen3")
+
+# OpenAI
+Agent("assistant", model="gpt-4", api_key="sk-...")
+
+# vLLM, LM Studio, etc.
+Agent("assistant", model="mistral", api_base="http://localhost:8000/v1")
+```
+
+## MCP Integration
+
+Connect to Model Context Protocol servers:
+
+```python
+agent.with_mcp(["http://localhost:3000"])
+agent.with_mcp([{"url": "https://api.com/mcp", "headers": {"Auth": "token"}}])
+```
+
+## API Reference
+
+### Agent
+```python
+agent = Agent(name, model="qwen3", enable_memory=True)
+agent.with_tools([func1, func2])         # Add tools
+agent.with_mcp([url])                    # Connect MCP servers
+
+await agent.call("tool", params)         # Direct execution
+await agent.infer("natural language")    # LLM routing
+
+agent.remember(content, importance=0.8)  # Store
+agent.recall(query)                      # Search
+```
+
+### Workflows
+```python
+agent("task")                            # Create step
+step1 >> step2                           # Sequential
+step1 & step2                            # Parallel
+await workflow.run()                     # Execute
+```
+
+### serve()
+```python
+serve(agent, port=8000, enable_cors=True)
+```
+
+**Endpoints:** `/execute`, `/process`, `/tools`, `/memory/remember`, `/memory/recall`, `/docs`
+
+## Examples
+
+```bash
+git clone https://github.com/hemanth/agentu
+cd agentu
+
+python examples/basic.py       # Simple agent
+python examples/workflow.py    # Workflows
+python examples/memory.py      # Memory system
+python examples/api.py         # REST API
+```
+
+## Testing
+
+```bash
+pytest
+pytest --cov=agentu
+```
+
+## License
+
+MIT

agentu-1.0.0/README.md

@@ -0,0 +1,200 @@
+# AgentU
+
+**The sleekest way to build AI agents.**
+
+```bash
+pip install agentu
+```
+
+## Why AgentU?
+
+```python
+# This is all you need:
+from agentu import Agent
+
+def search_products(query: str) -> list:
+    return db.products.search(query)
+
+agent = Agent("sales").with_tools([search_products])
+
+# Direct execution
+result = await agent.call("search_products", {"query": "laptop"})
+
+# Natural language (LLM figures out the tool + params)
+result = await agent.infer("Find me laptops under $1500")
+```
+
+## Workflows in 3 Lines
+
+```python
+# Sequential: researcher → analyst → writer
+workflow = researcher("Find AI trends") >> analyst("Analyze") >> writer("Summarize")
+
+# Parallel: run 3 searches concurrently
+workflow = search("AI") & search("ML") & search("Crypto")
+
+# Combined: parallel then merge
+workflow = (search("AI") & search("ML") & search("Crypto")) >> analyst("Compare")
+
+result = await workflow.run()
+```
+
+**`>>` chains steps. `&` runs in parallel.** That's the entire API.
+
+## Memory
+
+```python
+agent.remember("Customer prefers email", importance=0.9)
+memories = agent.recall(query="email")
+```
+
+Stored in SQLite. Searchable. Persistent.
+
+## REST API
+
+```python
+from agentu import serve
+
+serve(agent, port=8000)
+# curl -X POST localhost:8000/execute -d '{"tool_name": "search_products", ...}'
+```
+
+Auto-generated Swagger docs at `/docs`.
+
+## Real-World Example: Automated Code Review
+
+```python
+import asyncio
+from agentu import Agent
+
+def get_pr_diff(pr_number: int) -> str:
+    """Fetch PR changes from GitHub."""
+    # GitHub API integration
+    return "diff --git a/src/auth.py... +added_line -removed_line"
+
+def run_tests(branch: str) -> dict:
+    """Run test suite."""
+    return {"passed": 47, "failed": 2, "coverage": 94.2}
+
+def post_comment(pr_number: int, comment: str) -> bool:
+    """Post review comment to GitHub."""
+    return True
+
+async def main():
+    # Setup agents
+    reviewer = Agent("reviewer", model="gpt-4").with_tools([get_pr_diff])
+    tester = Agent("tester").with_tools([run_tests])
+    commenter = Agent("commenter").with_tools([post_comment])
+
+    # Parallel: review code + run tests
+    workflow = reviewer("Review PR #247") & tester("Run tests on PR #247")
+    code_review, test_results = await workflow.run()
+
+    # Natural language: synthesize findings
+    summary = await commenter.infer(
+        f"Create a review comment for PR #247. "
+        f"Code review: {code_review}. Tests: {test_results}. "
+        f"Be constructive and specific."
+    )
+
+    # Post to GitHub
+    await commenter.call("post_comment", {"pr_number": 247, "comment": summary})
+    print("✓ Review posted to PR #247")
+
+asyncio.run(main())
+```
+
+**What this does:**
+- Reviews code and runs tests **in parallel** (saves time)
+- Uses `infer()` to write **human-quality review comments**
+- Posts directly to GitHub
+- **Zero manual work** - runs on every PR
+
+## Advanced: Lambda Control
+
+Need precise data flow? Use lambdas:
+
+```python
+workflow = (
+    researcher("Find companies")
+    >> analyst(lambda prev: f"Extract top 5 from: {prev['result']}")
+    >> writer(lambda prev: f"Write report about: {prev['companies']}")
+)
+```
+
+## LLM Support
+
+Works with any OpenAI-compatible API:
+
+```python
+# Ollama (default)
+Agent("assistant", model="qwen3")
+
+# OpenAI
+Agent("assistant", model="gpt-4", api_key="sk-...")
+
+# vLLM, LM Studio, etc.
+Agent("assistant", model="mistral", api_base="http://localhost:8000/v1")
+```
+
+## MCP Integration
+
+Connect to Model Context Protocol servers:
+
+```python
+agent.with_mcp(["http://localhost:3000"])
+agent.with_mcp([{"url": "https://api.com/mcp", "headers": {"Auth": "token"}}])
+```
+
+## API Reference
+
+### Agent
+```python
+agent = Agent(name, model="qwen3", enable_memory=True)
+agent.with_tools([func1, func2])         # Add tools
+agent.with_mcp([url])                    # Connect MCP servers
+
+await agent.call("tool", params)         # Direct execution
+await agent.infer("natural language")    # LLM routing
+
+agent.remember(content, importance=0.8)  # Store
+agent.recall(query)                      # Search
+```
+
+### Workflows
+```python
+agent("task")                            # Create step
+step1 >> step2                           # Sequential
+step1 & step2                            # Parallel
+await workflow.run()                     # Execute
+```
+
+### serve()
+```python
+serve(agent, port=8000, enable_cors=True)
+```
+
+**Endpoints:** `/execute`, `/process`, `/tools`, `/memory/remember`, `/memory/recall`, `/docs`
+
+## Examples
+
+```bash
+git clone https://github.com/hemanth/agentu
+cd agentu
+
+python examples/basic.py       # Simple agent
+python examples/workflow.py    # Workflows
+python examples/memory.py      # Memory system
+python examples/api.py         # REST API
+```
+
+## Testing
+
+```bash
+pytest
+pytest --cov=agentu
+```
+
+## License
+
+MIT

agentu-1.0.0/examples/api.py

@@ -0,0 +1,17 @@
+"""Serve agent as REST API."""
+from agentu import Agent, serve
+
+
+def get_status(order_id: str) -> dict:
+    """Get order status."""
+    return {"order_id": order_id, "status": "shipped"}
+
+
+# Create agent
+agent = Agent("support").with_tools([get_status])
+
+# Serve on port 8000
+# curl -X POST http://localhost:8000/execute \
+#   -H "Content-Type: application/json" \
+#   -d '{"tool_name": "get_status", "parameters": {"order_id": "12345"}}'
+serve(agent, port=8000)

agentu-1.0.0/examples/basic.py

@@ -0,0 +1,29 @@
+"""Basic agent with tools."""
+import asyncio
+from agentu import Agent
+
+
+def add(x: int, y: int) -> int:
+    """Add two numbers."""
+    return x + y
+
+
+def multiply(x: int, y: int) -> int:
+    """Multiply two numbers."""
+    return x * y
+
+
+async def main():
+    # Create agent and add tools
+    agent = Agent("calculator").with_tools([add, multiply])
+
+    # Direct execution (no LLM needed)
+    result = await agent.call("add", {"x": 5, "y": 3})
+    print(f"5 + 3 = {result}")
+
+    result = await agent.call("multiply", {"x": 5, "y": 3})
+    print(f"5 * 3 = {result}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

agentu-1.0.0/examples/memory.py

@@ -0,0 +1,25 @@
+"""Agent with memory."""
+import asyncio
+from agentu import Agent
+
+
+async def main():
+    agent = Agent("assistant", enable_memory=True)
+
+    # Store facts
+    agent.remember("User prefers email", memory_type="fact", importance=0.8)
+    agent.remember("Customer ordered item #12345", memory_type="conversation")
+
+    # Recall
+    memories = agent.recall(query="email", limit=5)
+    for mem in memories:
+        print(f"- {mem.content}")
+
+    # Stats
+    stats = agent.get_memory_stats()
+    print(f"\nShort-term: {stats['short_term_size']}")
+    print(f"Long-term: {stats['long_term_size']}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

agentu-1.0.0/examples/orchestrator.py

@@ -0,0 +1,33 @@
+"""Workflow composition examples."""
+import asyncio
+from agentu import Agent
+
+
+def research(topic: str) -> dict:
+    """Research a topic."""
+    return {"topic": topic, "findings": f"Findings about {topic}"}
+
+
+def analyze(data: str) -> dict:
+    """Analyze data."""
+    return {"analysis": "Mock analysis", "confidence": 0.85}
+
+
+async def main():
+    # Create agents
+    researcher = Agent("researcher").with_tools([research])
+    analyst = Agent("analyst").with_tools([analyze])
+
+    # Sequential workflow
+    workflow = researcher("Research AI trends") >> analyst("Analyze findings")
+    result = await workflow.run()
+    print(f"Sequential result: {result}")
+
+    # Parallel workflow
+    workflow = researcher("AI") & researcher("ML") & researcher("Crypto")
+    results = await workflow.run()
+    print(f"Parallel results: {len(results)} tasks completed")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())