| Name | tagent JSON |
| Version |
0.5.5
JSON |
| download |
| home_page | None |
| Summary | TAgent - Modular AI Agent Framework with Dynamic Tool Discovery |
| upload_time | 2025-07-15 00:22:26 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.8 |
| license | None |
| keywords |
ai
agent
llm
automation
framework
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# TAgent - When You're Tired of Unnecessarily Complex Agent Frameworks
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://github.com/yourusername/tagent2)
> **A minimalist, Redux-inspired framework for AI agents that actually makes sense**
Fed up with bloated frameworks that need 50 dependencies and 200 lines of boilerplate just to make a simple automation? TAgent is a straightforward, less verbose approach to building AI agents that solve specific problems without the unnecessary complexity.
## Why TAgent?
TAgent follows a simple philosophy: **state-controlled execution with LLM fallbacks**. Instead of complex function calling or massive dependency trees, you get:
- **Redux-inspired Architecture**: Predictable state management with centralized store
- **State Machine Control**: Prevents infinite loops and unpredictable behavior
- **Structured Outputs**: Works with any LLM via JSON, not function calling
- **Intelligent Fallbacks**: When tools don't exist, uses LLM knowledge directly
- **Zero Boilerplate**: Get started with 3 lines of code
## Quick Start
```bash
pip install -e .
```
```python
from tagent import run_agent
from tagent.config import TAgentConfig
# Simple usage with configuration
config = TAgentConfig(
model="gpt-4o-mini",
max_iterations=3,
verbose=True
)
result = run_agent(
goal="Translate 'Hello world' to Chinese",
config=config
)
print(result.get("raw_data", {}).get("llm_direct_response"))
# Output: 你好世界
```
## Configuration System
TAgent v0.5.0 introduces a comprehensive configuration system that centralizes all agent settings. You can configure UI style, model settings, execution parameters, and more.
### Basic Configuration
```python
from tagent import run_agent
from tagent.config import TAgentConfig
from tagent.ui.factory import UIStyle
# Create configuration
config = TAgentConfig(
model="gpt-4o-mini",
max_iterations=10,
verbose=True,
ui_style=UIStyle.INSTITUTIONAL, # or UIStyle.ANIMATED
api_key="your-api-key"
)
# Use configuration
result = run_agent("Your goal here", config=config)
```
### Environment Variables
Configure TAgent using environment variables:
```bash
export TAGENT_MODEL="gpt-4o-mini"
export TAGENT_MAX_ITERATIONS=20
export TAGENT_VERBOSE=true
export TAGENT_UI_STYLE=institutional # or animated
export TAGENT_API_KEY="your-api-key"
```
### UI Styles
TAgent supports two UI styles:
#### Animated UI (Matrix-style)
- Retro terminal effects with typing animations
- Blinking cursor and thinking animations
- Colorful output perfect for demonstrations
#### Institutional UI (Server-focused)
- Clean, structured logging: `timestamp [LEVEL] COMPONENT: message`
- No animations, optimized for server environments
- Perfect for production and log analysis
```python
# Set UI style programmatically
from tagent.ui import set_ui_style
from tagent.ui.factory import UIStyle
set_ui_style(UIStyle.INSTITUTIONAL)
```
### CLI Tool Configuration
TAgent provides a CLI for running agents with dynamic tool discovery:
```bash
# Run without tools (uses LLM knowledge only)
python -m tagent "What is 2+2?" --model gpt-4o-mini
# Run with tools from specific directory
python -m tagent "Analyze recent articles" --search-dir ./examples/tab_news_analyzer
# Run with specific tool files
python -m tagent "Plan a trip" --tools ./travel/tagent.tools.py --tools ./weather/tagent.tools.py
```
### Tool Discovery Options
The CLI supports several ways to configure tool loading:
- **`--tools`** - Specify exact paths to `tagent.tools.py` files
- **`--search-dir`** - Search directories for tool files (supports multiple directories)
- **`--recursive`** - Search directories recursively (default: True)
- **`--no-recursive`** - Disable recursive search
- **`--output`** - Specify path to `tagent.output.py` for structured outputs
### Default Behavior
**Important**: When no tool configuration is provided, TAgent runs **without tools** and uses LLM knowledge only. This prevents unwanted recursive searches in your entire file system.
```bash
# These run without tools:
python -m tagent "Simple question"
python -m tagent "Calculate something" --model gpt-4o-mini
# These search for tools:
python -m tagent "Complex task" --search-dir .
python -m tagent "Use specific tool" --tools ./my_tools/tagent.tools.py
```
### Tool File Structure
Tools must be in files named `tagent.tools.py` with this signature:
```python
def my_tool(state: Dict[str, Any], args: Dict[str, Any]) -> Optional[Tuple[str, Any]]:
"""
Tool description here.
Args:
state: Current agent state
args: Tool arguments from LLM
Returns:
Tuple of (key, value) for state update
"""
# Your tool logic here
return ("result_key", result_value)
```
### Examples
```bash
# Run with tools from current directory (recursive search)
python -m tagent "Analyze data" --search-dir . --recursive
# Run with tools from specific directories only
python -m tagent "Multi-step task" --search-dir ./tools --search-dir ./integrations
# Run with exact tool files and custom output format
python -m tagent "Generate report" --tools ./reporting/tagent.tools.py --output ./reporting/tagent.output.py
# Run without any tools (LLM knowledge only)
python -m tagent "Simple calculation" --model gpt-4o-mini
```
## How It Works Under the Hood
### Deterministic State Machine
Instead of letting the LLM do whatever it wants, the agent follows a controlled flow:
```
INITIAL → PLAN → EXECUTE → EVALUATE → (loop until goal achieved)
```
Each transition is validated, preventing infinite loops and unpredictable behaviors.
## State Machine Architecture (v0.5.0)
TAgent v0.5.0 implements a sophisticated state machine that ensures predictable execution flow and prevents infinite loops. The architecture follows strict transition rules while giving the AI strategic decision points.
### Complete State Flow Diagram
```
🚀 INITIAL
│
│ (automatic)
▼
PLAN ◄──────────────────────┐
│ │
│ (automatic) │
▼ │
EXECUTE │
│ │
│ (AI chooses) │
├─────────────┐ │
│ │ │
▼ ▼ │
EXECUTE SUMMARIZE │
(loop) │ │
│(automatic) │
▼ │
EVALUATE │
│ │
│(automatic) │
└────────────┘
```
### State Transition Rules
#### Mandatory Transitions (Automatic)
These transitions happen automatically without AI choice:
- **INITIAL → PLAN**: Agent must start by creating a plan
- **PLAN → EXECUTE**: Plans must be executed
- **SUMMARIZE → EVALUATE**: Summaries trigger evaluation
- **EVALUATE → PLAN**: Evaluations trigger re-planning
#### AI Decision Points
The AI can choose between multiple options at these states:
- **EXECUTE**: Can choose to:
- Continue with another **EXECUTE** action (tool usage, data processing)
- Move to **SUMMARIZE** when ready to conclude
### Execution Flow Examples
#### Simple Task Flow
```
INITIAL → PLAN → EXECUTE → SUMMARIZE → EVALUATE → PLAN (goal achieved)
```
#### Complex Multi-Step Task
```
INITIAL → PLAN → EXECUTE → EXECUTE → EXECUTE → SUMMARIZE → EVALUATE → PLAN → EXECUTE → SUMMARIZE → EVALUATE (complete)
```
#### Failed Execution Recovery
```
INITIAL → PLAN → EXECUTE (fails) → EXECUTE (retry) → SUMMARIZE → EVALUATE (needs replanning) → PLAN → EXECUTE → SUMMARIZE → EVALUATE (success)
```
### State Descriptions
#### 🚀 INITIAL
- **Purpose**: Entry point for the agent
- **Behavior**: Automatically transitions to PLAN
- **Duration**: Instantaneous
#### 📋 PLAN
- **Purpose**: Create strategic plan based on goal and current state
- **Behavior**: Automatically transitions to EXECUTE
- **LLM Task**: Generate actionable steps and identify required tools
- **Output**: Structured plan with next actions
#### ⚡ EXECUTE
- **Purpose**: Perform actions, use tools, process data
- **Behavior**: AI chooses next state (EXECUTE again or SUMMARIZE)
- **LLM Task**: Execute tools, process information, make progress
- **Decision Logic**:
- Choose **EXECUTE** if more work needed
- Choose **SUMMARIZE** if ready to conclude
#### 📊 SUMMARIZE
- **Purpose**: Consolidate results and prepare evaluation
- **Behavior**: Automatically transitions to EVALUATE
- **LLM Task**: Synthesize all work done and results achieved
- **Output**: Comprehensive summary of progress
#### 🔍 EVALUATE
- **Purpose**: Assess if goal is achieved and determine next steps
- **Behavior**: Automatically transitions to PLAN
- **LLM Task**: Determine if goal is met or what needs to be done next
- **Decision Logic**:
- If goal achieved: Mark as complete
- If more work needed: Continue with new planning cycle
### Loop Prevention Mechanisms
The state machine implements several mechanisms to prevent infinite loops:
#### 1. **Max Iterations Control**
```python
config = TAgentConfig(max_iterations=10) # Limits total EXECUTE actions
```
#### 2. **State Transition Validation**
- Prevents invalid transitions (e.g., SUMMARIZE → SUMMARIZE)
- Enforces mandatory paths
- Validates state consistency
#### 3. **Progress Tracking**
- Monitors if agent is making meaningful progress
- Detects repetitive behaviors
- Triggers intervention when stuck
#### 4. **Strategic Choice Points**
- AI only has decision power at specific moments
- Reduces unpredictable behavior
- Maintains deterministic flow
### Implementation Benefits
#### 🎯 **Predictable Execution**
- Every agent run follows the same pattern
- Debugging is straightforward
- Behavior is reproducible
#### 🚫 **Loop Prevention**
- Impossible to get stuck in SUMMARIZE loops
- EVALUATE always returns to productive work
- Maximum iteration limits prevent runaway execution
#### 🔄 **Self-Correction**
- Failed executions trigger re-planning
- Agent can adapt strategy based on results
- Built-in recovery mechanisms
#### 📊 **Progress Visibility**
- Clear state indicators show agent progress
- Easy to understand where agent is in the process
- Helpful for debugging and monitoring
### Advanced State Management
#### State Persistence
```python
# State is maintained throughout execution
state = {
"goal": "Original user goal",
"current_state": "EXECUTE",
"iteration": 3,
"tools_used": ["search", "translate"],
"results": {...}
}
```
#### State Validation
```python
# Each transition is validated
def validate_transition(current_state: str, next_state: str) -> bool:
valid_transitions = {
"INITIAL": ["PLAN"],
"PLAN": ["EXECUTE"],
"EXECUTE": ["EXECUTE", "SUMMARIZE"],
"SUMMARIZE": ["EVALUATE"],
"EVALUATE": ["PLAN"]
}
return next_state in valid_transitions.get(current_state, [])
```
This architecture ensures TAgent remains controllable and predictable while still allowing the AI to make intelligent decisions about execution flow.
### Structured Outputs Over Function Calling
No function calling dependency. The LLM returns structured JSON validated with Pydantic:
```json
{
"action": "execute",
"params": {"tool": "search", "args": {"query": "python"}},
"reasoning": "Need to search for Python information"
}
```
### Intelligent Fallback System
If a tool doesn't exist, the agent uses the LLM's own knowledge as fallback. No crashes, no errors - it just works.
```python
# Tool not found? No problem!
# Agent automatically uses LLM knowledge instead
```
## Real-World Example
Here's an agent that extracts and translates TabNews articles:
```python
def extract_tabnews_articles(state, args):
"""Extract recent articles from TabNews RSS"""
response = requests.get("https://www.tabnews.com.br/recentes/rss")
root = ET.fromstring(response.content)
articles = []
for item in root.findall('.//item'):
articles.append({
"url": item.find('link').text,
"title": item.find('title').text,
"publication_date": item.find('pubDate').text
})
return ("articles", articles)
def translate(state, args):
"""Translate text using direct LLM call"""
text = args.get("text", "")
target = args.get("target_language", "")
response = litellm.completion(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "You are a professional translator."},
{"role": "user", "content": f"Translate to {target}: {text}"}
]
)
return ("translation", {"translation": response.choices[0].message.content})
# Run the agent with configuration
config = TAgentConfig(
model="gpt-4o-mini",
max_iterations=15,
tools={
"extract_tabnews_articles": extract_tabnews_articles,
"load_url_content": load_url_content,
"translate": translate
},
verbose=True
)
result = run_agent(
goal="Get 1 TabNews article, load content, summarize and translate to Chinese",
config=config
)
```
The agent plans, executes tools in the correct order, and delivers structured results.
## Tool Ecosystem & Extensibility
Currently no default tools (keeping it minimal), but adapters are being developed for:
- **CrewAI** tools
- **LangChain** tools
- **Model Context Protocol (MCP)** tools
The idea is to leverage existing ecosystems without being locked into them.
## Why Redux for Agents?
- **Predictable State**: Always know what's happening
- **Debug Friendly**: Every step is logged and inspectable
- **Composition**: Tools are pure functions, easy to test
- **Extensible**: Adding new actions is trivial
- **Time Travel**: Replay actions for debugging
## Performance & Model Support
Works with any model via LiteLLM:
- OpenAI (GPT-4, GPT-3.5)
- Anthropic (Claude)
- Ollama (local models)
- OpenRouter
- Google Gemini
- Azure OpenAI
- And 100+ more...
Each action type can use a different model (planning with GPT-4, execution with cheaper model).
## UI Styles in Action
### Animated UI (Matrix-style)
Perfect for demonstrations and interactive use:
```
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓ T-AGENT v0.5.0 STARTING ▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
[-] [12:34:56] INIT: Goal: Translate hello world to Chinese
[#] [12:34:57] PLAN: Generating strategic plan...
[>] [12:34:58] EXECUTE: Using LLM fallback for translation
[+] [12:34:59] SUCCESS: Translation completed!
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
★ MISSION COMPLETE ★
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
```
### Institutional UI (Server-focused)
Clean, structured logging for production environments:
```
2025-07-14 12:34:56 [INFO ] SYSTEM: Banner: T-AGENT v0.5.0 STARTING
2025-07-14 12:34:56 [INFO ] AGENT: INIT: Goal: Translate hello world to Chinese
2025-07-14 12:34:57 [INFO ] PLANNER: Plan: Generate strategic plan for translation
2025-07-14 12:34:58 [INFO ] EXECUTE: Using LLM fallback for translation
2025-07-14 12:34:59 [INFO ] AGENT: SUCCESS: Translation completed!
```
Choose the style that fits your environment:
```python
from tagent.config import TAgentConfig
from tagent.ui.factory import UIStyle
# For development/demos
config = TAgentConfig(ui_style=UIStyle.ANIMATED)
# For production/servers
config = TAgentConfig(ui_style=UIStyle.INSTITUTIONAL)
```
## Architecture Overview
```
TAgent Framework
├── 🎯 State Machine Controller
│ ├── Deterministic action flow
│ ├── Loop prevention
│ └── Transition validation
├── 🤖 Agent Core
│ ├── Redux-inspired store
│ ├── LLM decision making
│ ├── Tool execution
│ └── Intelligent fallbacks
├── 🛠️ Tool System
│ ├── Pure function interface
│ ├── Dynamic discovery
│ └── Type-safe signatures
└── 📊 Structured Outputs
├── Pydantic validation
├── JSON schema enforcement
└── Type-safe results
```
## Advanced Configuration
### Model Configuration
```python
from tagent.config import TAgentConfig
from tagent.model_config import AgentModelConfig
# Advanced model configuration with step-specific models
model_config = AgentModelConfig(
tagent_model="gpt-4o", # Global fallback
tagent_planner_model="gpt-4o-mini", # Planning tasks
tagent_executor_model="gpt-3.5-turbo", # Tool execution
api_key="your-api-key"
)
config = TAgentConfig(
model=model_config, # Pass advanced model config
max_iterations=20,
verbose=True,
ui_style=UIStyle.INSTITUTIONAL
)
result = run_agent(
goal="Complex multi-step task",
config=config
)
```
### Configuration File Support
```python
from tagent.config import load_config
# Load from JSON file
config = load_config("config.json")
# Load from YAML file (requires PyYAML)
config = load_config("config.yaml")
# Load with environment override
config = load_config("config.json", env_override=True)
```
### Configuration Merging
```python
from tagent.config import TAgentConfig
# Base configuration
base_config = TAgentConfig(
model="gpt-4o-mini",
max_iterations=10
)
# Override specific settings
prod_config = TAgentConfig(
ui_style=UIStyle.INSTITUTIONAL,
verbose=False
)
# Merge configurations
final_config = base_config.merge(prod_config)
```
### Environment Variables
```bash
export TAGENT_MODEL="gpt-4o-mini"
export TAGENT_PLANNER_MODEL="gpt-4o"
export TAGENT_MAX_ITERATIONS=20
export TAGENT_VERBOSE=true
export TAGENT_UI_STYLE=institutional
export TAGENT_API_KEY="your-key"
```
## Try It Yourself
```bash
# Clone the repository
git clone https://github.com/yourusername/tagent2
cd tagent2
# Install in development mode
pip install -e .
# Try without tools (uses LLM knowledge only)
python -m tagent "What is the capital of France?" --model gpt-4o-mini
# Try with tools from an example
python -m tagent "Get recent TabNews articles" --search-dir ./examples/tab_news_analyzer
# Run the TabNews example programmatically
python examples/tab_news_analyzer/tabnews_code_example.py
```
## Examples Directory
Check out the `/examples` folder for real implementations:
- **`tab_news_analyzer/`** - Extract and translate TabNews articles
- **`travel_planning/`** - Multi-step travel planning agent
- **`simple_qa/`** - Direct question answering without tools
Each example shows different patterns and use cases.
## What's New in v0.5.0
### Configuration System
- ✅ Centralized configuration via `TAgentConfig`
- ✅ Environment variable support
- ✅ Configuration file support (JSON/YAML)
- ✅ Configuration merging and inheritance
### UI System Redesign
- ✅ Modular UI architecture with strategy pattern
- ✅ **Animated UI**: Matrix-style terminal effects
- ✅ **Institutional UI**: Clean structured logging
- ✅ Runtime UI style switching
### Developer Experience
- ✅ Better error handling and diagnostics
- ✅ Improved debugging capabilities
- ✅ Type-safe configuration system
- ✅ Comprehensive documentation
## Roadmap
- [ ] CrewAI/LangChain/MCP tool adapters
- [ ] Persistent memory system
- [ ] Default tool library (web search, file ops)
- [ ] Optional web interface
- [ ] Multi-agent orchestration
- [ ] Tool marketplace/registry
## Contributing
1. Fork the repository
2. Create a feature branch: `git checkout -b feature/amazing-feature`
3. Make your changes
4. Add tests if applicable
5. Commit: `git commit -m "Add amazing feature"`
6. Push: `git push origin feature/amazing-feature`
7. Open a Pull Request
## License
MIT License - see [LICENSE](LICENSE) file for details.
## Conclusion
TAgent won't solve all the world's problems, but if you want to create agents without headaches and with code you can understand 6 months later, it might be worth a look.
The framework is small (<2000 lines), focused, and each component has a clear responsibility. Sometimes simple is better.
---
**Repository:** https://github.com/yourusername/tagent2
**License:** MIT
**Version:** 0.5.0
*If you made it this far and found it interesting, leave a star on GitHub. If you didn't like it, open an issue and complain - feedback is always welcome.*
Raw data
{
"_id": null,
"home_page": null,
"name": "tagent",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "TAgent Development Team <tagent@example.com>",
"keywords": "ai, agent, llm, automation, framework",
"author": null,
"author_email": "TAgent Development Team <tagent@example.com>",
"download_url": "https://files.pythonhosted.org/packages/0d/58/df71e8a196d176207942c52751bef9d2cd8f380c7735b11287ac10fbf233/tagent-0.5.5.tar.gz",
"platform": null,
"description": "# TAgent - When You're Tired of Unnecessarily Complex Agent Frameworks\n\n[](https://www.python.org/downloads/)\n[](https://opensource.org/licenses/MIT)\n[](https://github.com/yourusername/tagent2)\n\n> **A minimalist, Redux-inspired framework for AI agents that actually makes sense**\n\nFed up with bloated frameworks that need 50 dependencies and 200 lines of boilerplate just to make a simple automation? TAgent is a straightforward, less verbose approach to building AI agents that solve specific problems without the unnecessary complexity.\n\n\n\n## Why TAgent?\n\nTAgent follows a simple philosophy: **state-controlled execution with LLM fallbacks**. Instead of complex function calling or massive dependency trees, you get:\n\n- **Redux-inspired Architecture**: Predictable state management with centralized store\n- **State Machine Control**: Prevents infinite loops and unpredictable behavior \n- **Structured Outputs**: Works with any LLM via JSON, not function calling\n- **Intelligent Fallbacks**: When tools don't exist, uses LLM knowledge directly\n- **Zero Boilerplate**: Get started with 3 lines of code\n\n## Quick Start\n\n```bash\npip install -e .\n```\n\n```python\nfrom tagent import run_agent\nfrom tagent.config import TAgentConfig\n\n# Simple usage with configuration\nconfig = TAgentConfig(\n model=\"gpt-4o-mini\",\n max_iterations=3,\n verbose=True\n)\n\nresult = run_agent(\n goal=\"Translate 'Hello world' to Chinese\",\n config=config\n)\n\nprint(result.get(\"raw_data\", {}).get(\"llm_direct_response\"))\n# Output: \u4f60\u597d\u4e16\u754c\n```\n\n## Configuration System\n\nTAgent v0.5.0 introduces a comprehensive configuration system that centralizes all agent settings. You can configure UI style, model settings, execution parameters, and more.\n\n### Basic Configuration\n\n```python\nfrom tagent import run_agent\nfrom tagent.config import TAgentConfig\nfrom tagent.ui.factory import UIStyle\n\n# Create configuration\nconfig = TAgentConfig(\n model=\"gpt-4o-mini\",\n max_iterations=10,\n verbose=True,\n ui_style=UIStyle.INSTITUTIONAL, # or UIStyle.ANIMATED\n api_key=\"your-api-key\"\n)\n\n# Use configuration\nresult = run_agent(\"Your goal here\", config=config)\n```\n\n### Environment Variables\n\nConfigure TAgent using environment variables:\n\n```bash\nexport TAGENT_MODEL=\"gpt-4o-mini\"\nexport TAGENT_MAX_ITERATIONS=20\nexport TAGENT_VERBOSE=true\nexport TAGENT_UI_STYLE=institutional # or animated\nexport TAGENT_API_KEY=\"your-api-key\"\n```\n\n### UI Styles\n\nTAgent supports two UI styles:\n\n#### Animated UI (Matrix-style)\n- Retro terminal effects with typing animations\n- Blinking cursor and thinking animations\n- Colorful output perfect for demonstrations\n\n#### Institutional UI (Server-focused)\n- Clean, structured logging: `timestamp [LEVEL] COMPONENT: message`\n- No animations, optimized for server environments\n- Perfect for production and log analysis\n\n```python\n# Set UI style programmatically\nfrom tagent.ui import set_ui_style\nfrom tagent.ui.factory import UIStyle\n\nset_ui_style(UIStyle.INSTITUTIONAL)\n```\n\n### CLI Tool Configuration\n\nTAgent provides a CLI for running agents with dynamic tool discovery:\n\n```bash\n# Run without tools (uses LLM knowledge only)\npython -m tagent \"What is 2+2?\" --model gpt-4o-mini\n\n# Run with tools from specific directory\npython -m tagent \"Analyze recent articles\" --search-dir ./examples/tab_news_analyzer\n\n# Run with specific tool files\npython -m tagent \"Plan a trip\" --tools ./travel/tagent.tools.py --tools ./weather/tagent.tools.py\n```\n\n### Tool Discovery Options\n\nThe CLI supports several ways to configure tool loading:\n\n- **`--tools`** - Specify exact paths to `tagent.tools.py` files\n- **`--search-dir`** - Search directories for tool files (supports multiple directories)\n- **`--recursive`** - Search directories recursively (default: True)\n- **`--no-recursive`** - Disable recursive search\n- **`--output`** - Specify path to `tagent.output.py` for structured outputs\n\n### Default Behavior\n\n**Important**: When no tool configuration is provided, TAgent runs **without tools** and uses LLM knowledge only. This prevents unwanted recursive searches in your entire file system.\n\n```bash\n# These run without tools:\npython -m tagent \"Simple question\"\npython -m tagent \"Calculate something\" --model gpt-4o-mini\n\n# These search for tools:\npython -m tagent \"Complex task\" --search-dir .\npython -m tagent \"Use specific tool\" --tools ./my_tools/tagent.tools.py\n```\n\n### Tool File Structure\n\nTools must be in files named `tagent.tools.py` with this signature:\n\n```python\ndef my_tool(state: Dict[str, Any], args: Dict[str, Any]) -> Optional[Tuple[str, Any]]:\n \"\"\"\n Tool description here.\n \n Args:\n state: Current agent state\n args: Tool arguments from LLM\n \n Returns:\n Tuple of (key, value) for state update\n \"\"\"\n # Your tool logic here\n return (\"result_key\", result_value)\n```\n\n### Examples\n\n```bash\n# Run with tools from current directory (recursive search)\npython -m tagent \"Analyze data\" --search-dir . --recursive\n\n# Run with tools from specific directories only\npython -m tagent \"Multi-step task\" --search-dir ./tools --search-dir ./integrations\n\n# Run with exact tool files and custom output format\npython -m tagent \"Generate report\" --tools ./reporting/tagent.tools.py --output ./reporting/tagent.output.py\n\n# Run without any tools (LLM knowledge only)\npython -m tagent \"Simple calculation\" --model gpt-4o-mini\n```\n\n## How It Works Under the Hood\n\n### Deterministic State Machine\nInstead of letting the LLM do whatever it wants, the agent follows a controlled flow:\n\n```\nINITIAL \u2192 PLAN \u2192 EXECUTE \u2192 EVALUATE \u2192 (loop until goal achieved)\n```\n\nEach transition is validated, preventing infinite loops and unpredictable behaviors.\n\n## State Machine Architecture (v0.5.0)\n\nTAgent v0.5.0 implements a sophisticated state machine that ensures predictable execution flow and prevents infinite loops. The architecture follows strict transition rules while giving the AI strategic decision points.\n\n### Complete State Flow Diagram\n\n```\n \ud83d\ude80 INITIAL\n \u2502\n \u2502 (automatic)\n \u25bc\n PLAN \u25c4\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n \u2502 \u2502\n \u2502 (automatic) \u2502\n \u25bc \u2502\n EXECUTE \u2502\n \u2502 \u2502\n \u2502 (AI chooses) \u2502\n \u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510 \u2502\n \u2502 \u2502 \u2502\n \u25bc \u25bc \u2502\n EXECUTE SUMMARIZE \u2502\n (loop) \u2502 \u2502\n \u2502(automatic) \u2502\n \u25bc \u2502\n EVALUATE \u2502\n \u2502 \u2502\n \u2502(automatic) \u2502\n \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n```\n\n### State Transition Rules\n\n#### Mandatory Transitions (Automatic)\nThese transitions happen automatically without AI choice:\n\n- **INITIAL \u2192 PLAN**: Agent must start by creating a plan\n- **PLAN \u2192 EXECUTE**: Plans must be executed\n- **SUMMARIZE \u2192 EVALUATE**: Summaries trigger evaluation\n- **EVALUATE \u2192 PLAN**: Evaluations trigger re-planning\n\n#### AI Decision Points\nThe AI can choose between multiple options at these states:\n\n- **EXECUTE**: Can choose to:\n - Continue with another **EXECUTE** action (tool usage, data processing)\n - Move to **SUMMARIZE** when ready to conclude\n\n### Execution Flow Examples\n\n#### Simple Task Flow\n```\nINITIAL \u2192 PLAN \u2192 EXECUTE \u2192 SUMMARIZE \u2192 EVALUATE \u2192 PLAN (goal achieved)\n```\n\n#### Complex Multi-Step Task\n```\nINITIAL \u2192 PLAN \u2192 EXECUTE \u2192 EXECUTE \u2192 EXECUTE \u2192 SUMMARIZE \u2192 EVALUATE \u2192 PLAN \u2192 EXECUTE \u2192 SUMMARIZE \u2192 EVALUATE (complete)\n```\n\n#### Failed Execution Recovery\n```\nINITIAL \u2192 PLAN \u2192 EXECUTE (fails) \u2192 EXECUTE (retry) \u2192 SUMMARIZE \u2192 EVALUATE (needs replanning) \u2192 PLAN \u2192 EXECUTE \u2192 SUMMARIZE \u2192 EVALUATE (success)\n```\n\n### State Descriptions\n\n#### \ud83d\ude80 INITIAL\n- **Purpose**: Entry point for the agent\n- **Behavior**: Automatically transitions to PLAN\n- **Duration**: Instantaneous\n\n#### \ud83d\udccb PLAN\n- **Purpose**: Create strategic plan based on goal and current state\n- **Behavior**: Automatically transitions to EXECUTE\n- **LLM Task**: Generate actionable steps and identify required tools\n- **Output**: Structured plan with next actions\n\n#### \u26a1 EXECUTE\n- **Purpose**: Perform actions, use tools, process data\n- **Behavior**: AI chooses next state (EXECUTE again or SUMMARIZE)\n- **LLM Task**: Execute tools, process information, make progress\n- **Decision Logic**:\n - Choose **EXECUTE** if more work needed\n - Choose **SUMMARIZE** if ready to conclude\n\n#### \ud83d\udcca SUMMARIZE\n- **Purpose**: Consolidate results and prepare evaluation\n- **Behavior**: Automatically transitions to EVALUATE\n- **LLM Task**: Synthesize all work done and results achieved\n- **Output**: Comprehensive summary of progress\n\n#### \ud83d\udd0d EVALUATE\n- **Purpose**: Assess if goal is achieved and determine next steps\n- **Behavior**: Automatically transitions to PLAN\n- **LLM Task**: Determine if goal is met or what needs to be done next\n- **Decision Logic**:\n - If goal achieved: Mark as complete\n - If more work needed: Continue with new planning cycle\n\n### Loop Prevention Mechanisms\n\nThe state machine implements several mechanisms to prevent infinite loops:\n\n#### 1. **Max Iterations Control**\n```python\nconfig = TAgentConfig(max_iterations=10) # Limits total EXECUTE actions\n```\n\n#### 2. **State Transition Validation**\n- Prevents invalid transitions (e.g., SUMMARIZE \u2192 SUMMARIZE)\n- Enforces mandatory paths\n- Validates state consistency\n\n#### 3. **Progress Tracking**\n- Monitors if agent is making meaningful progress\n- Detects repetitive behaviors\n- Triggers intervention when stuck\n\n#### 4. **Strategic Choice Points**\n- AI only has decision power at specific moments\n- Reduces unpredictable behavior\n- Maintains deterministic flow\n\n### Implementation Benefits\n\n#### \ud83c\udfaf **Predictable Execution**\n- Every agent run follows the same pattern\n- Debugging is straightforward\n- Behavior is reproducible\n\n#### \ud83d\udeab **Loop Prevention**\n- Impossible to get stuck in SUMMARIZE loops\n- EVALUATE always returns to productive work\n- Maximum iteration limits prevent runaway execution\n\n#### \ud83d\udd04 **Self-Correction**\n- Failed executions trigger re-planning\n- Agent can adapt strategy based on results\n- Built-in recovery mechanisms\n\n#### \ud83d\udcca **Progress Visibility**\n- Clear state indicators show agent progress\n- Easy to understand where agent is in the process\n- Helpful for debugging and monitoring\n\n### Advanced State Management\n\n#### State Persistence\n```python\n# State is maintained throughout execution\nstate = {\n \"goal\": \"Original user goal\",\n \"current_state\": \"EXECUTE\",\n \"iteration\": 3,\n \"tools_used\": [\"search\", \"translate\"],\n \"results\": {...}\n}\n```\n\n#### State Validation\n```python\n# Each transition is validated\ndef validate_transition(current_state: str, next_state: str) -> bool:\n valid_transitions = {\n \"INITIAL\": [\"PLAN\"],\n \"PLAN\": [\"EXECUTE\"],\n \"EXECUTE\": [\"EXECUTE\", \"SUMMARIZE\"],\n \"SUMMARIZE\": [\"EVALUATE\"],\n \"EVALUATE\": [\"PLAN\"]\n }\n return next_state in valid_transitions.get(current_state, [])\n```\n\nThis architecture ensures TAgent remains controllable and predictable while still allowing the AI to make intelligent decisions about execution flow.\n\n### Structured Outputs Over Function Calling\nNo function calling dependency. The LLM returns structured JSON validated with Pydantic:\n\n```json\n{\n \"action\": \"execute\",\n \"params\": {\"tool\": \"search\", \"args\": {\"query\": \"python\"}},\n \"reasoning\": \"Need to search for Python information\"\n}\n```\n\n### Intelligent Fallback System\nIf a tool doesn't exist, the agent uses the LLM's own knowledge as fallback. No crashes, no errors - it just works.\n\n```python\n# Tool not found? No problem!\n# Agent automatically uses LLM knowledge instead\n```\n\n## Real-World Example\n\nHere's an agent that extracts and translates TabNews articles:\n\n```python\ndef extract_tabnews_articles(state, args):\n \"\"\"Extract recent articles from TabNews RSS\"\"\"\n response = requests.get(\"https://www.tabnews.com.br/recentes/rss\")\n root = ET.fromstring(response.content)\n \n articles = []\n for item in root.findall('.//item'):\n articles.append({\n \"url\": item.find('link').text,\n \"title\": item.find('title').text,\n \"publication_date\": item.find('pubDate').text\n })\n \n return (\"articles\", articles)\n\ndef translate(state, args):\n \"\"\"Translate text using direct LLM call\"\"\"\n text = args.get(\"text\", \"\")\n target = args.get(\"target_language\", \"\")\n \n response = litellm.completion(\n model=\"gpt-4o-mini\",\n messages=[\n {\"role\": \"system\", \"content\": \"You are a professional translator.\"},\n {\"role\": \"user\", \"content\": f\"Translate to {target}: {text}\"}\n ]\n )\n \n return (\"translation\", {\"translation\": response.choices[0].message.content})\n\n# Run the agent with configuration\nconfig = TAgentConfig(\n model=\"gpt-4o-mini\",\n max_iterations=15,\n tools={\n \"extract_tabnews_articles\": extract_tabnews_articles,\n \"load_url_content\": load_url_content,\n \"translate\": translate\n },\n verbose=True\n)\n\nresult = run_agent(\n goal=\"Get 1 TabNews article, load content, summarize and translate to Chinese\",\n config=config\n)\n```\n\nThe agent plans, executes tools in the correct order, and delivers structured results.\n\n## Tool Ecosystem & Extensibility\n\nCurrently no default tools (keeping it minimal), but adapters are being developed for:\n- **CrewAI** tools\n- **LangChain** tools \n- **Model Context Protocol (MCP)** tools\n\nThe idea is to leverage existing ecosystems without being locked into them.\n\n## Why Redux for Agents?\n\n- **Predictable State**: Always know what's happening\n- **Debug Friendly**: Every step is logged and inspectable\n- **Composition**: Tools are pure functions, easy to test\n- **Extensible**: Adding new actions is trivial\n- **Time Travel**: Replay actions for debugging\n\n## Performance & Model Support\n\nWorks with any model via LiteLLM:\n- OpenAI (GPT-4, GPT-3.5)\n- Anthropic (Claude)\n- Ollama (local models)\n- OpenRouter\n- Google Gemini\n- Azure OpenAI\n- And 100+ more...\n\nEach action type can use a different model (planning with GPT-4, execution with cheaper model).\n\n## UI Styles in Action\n\n### Animated UI (Matrix-style)\nPerfect for demonstrations and interactive use:\n\n```\n\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\n\u2593 T-AGENT v0.5.0 STARTING \u2593 \n\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\n[-] [12:34:56] INIT: Goal: Translate hello world to Chinese\n[#] [12:34:57] PLAN: Generating strategic plan...\n[>] [12:34:58] EXECUTE: Using LLM fallback for translation\n[+] [12:34:59] SUCCESS: Translation completed!\n\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\n\u2605 MISSION COMPLETE \u2605 \n\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\u2605\n```\n\n### Institutional UI (Server-focused)\nClean, structured logging for production environments:\n\n```\n2025-07-14 12:34:56 [INFO ] SYSTEM: Banner: T-AGENT v0.5.0 STARTING\n2025-07-14 12:34:56 [INFO ] AGENT: INIT: Goal: Translate hello world to Chinese\n2025-07-14 12:34:57 [INFO ] PLANNER: Plan: Generate strategic plan for translation\n2025-07-14 12:34:58 [INFO ] EXECUTE: Using LLM fallback for translation\n2025-07-14 12:34:59 [INFO ] AGENT: SUCCESS: Translation completed!\n```\n\nChoose the style that fits your environment:\n\n```python\nfrom tagent.config import TAgentConfig\nfrom tagent.ui.factory import UIStyle\n\n# For development/demos\nconfig = TAgentConfig(ui_style=UIStyle.ANIMATED)\n\n# For production/servers\nconfig = TAgentConfig(ui_style=UIStyle.INSTITUTIONAL)\n```\n\n## Architecture Overview\n\n```\nTAgent Framework\n\u251c\u2500\u2500 \ud83c\udfaf State Machine Controller\n\u2502 \u251c\u2500\u2500 Deterministic action flow\n\u2502 \u251c\u2500\u2500 Loop prevention\n\u2502 \u2514\u2500\u2500 Transition validation\n\u251c\u2500\u2500 \ud83e\udd16 Agent Core\n\u2502 \u251c\u2500\u2500 Redux-inspired store\n\u2502 \u251c\u2500\u2500 LLM decision making\n\u2502 \u251c\u2500\u2500 Tool execution\n\u2502 \u2514\u2500\u2500 Intelligent fallbacks\n\u251c\u2500\u2500 \ud83d\udee0\ufe0f Tool System\n\u2502 \u251c\u2500\u2500 Pure function interface\n\u2502 \u251c\u2500\u2500 Dynamic discovery\n\u2502 \u2514\u2500\u2500 Type-safe signatures\n\u2514\u2500\u2500 \ud83d\udcca Structured Outputs\n \u251c\u2500\u2500 Pydantic validation\n \u251c\u2500\u2500 JSON schema enforcement\n \u2514\u2500\u2500 Type-safe results\n```\n\n## Advanced Configuration\n\n### Model Configuration\n```python\nfrom tagent.config import TAgentConfig\nfrom tagent.model_config import AgentModelConfig\n\n# Advanced model configuration with step-specific models\nmodel_config = AgentModelConfig(\n tagent_model=\"gpt-4o\", # Global fallback\n tagent_planner_model=\"gpt-4o-mini\", # Planning tasks\n tagent_executor_model=\"gpt-3.5-turbo\", # Tool execution\n api_key=\"your-api-key\"\n)\n\nconfig = TAgentConfig(\n model=model_config, # Pass advanced model config\n max_iterations=20,\n verbose=True,\n ui_style=UIStyle.INSTITUTIONAL\n)\n\nresult = run_agent(\n goal=\"Complex multi-step task\",\n config=config\n)\n```\n\n### Configuration File Support\n```python\nfrom tagent.config import load_config\n\n# Load from JSON file\nconfig = load_config(\"config.json\")\n\n# Load from YAML file (requires PyYAML)\nconfig = load_config(\"config.yaml\")\n\n# Load with environment override\nconfig = load_config(\"config.json\", env_override=True)\n```\n\n### Configuration Merging\n```python\nfrom tagent.config import TAgentConfig\n\n# Base configuration\nbase_config = TAgentConfig(\n model=\"gpt-4o-mini\",\n max_iterations=10\n)\n\n# Override specific settings\nprod_config = TAgentConfig(\n ui_style=UIStyle.INSTITUTIONAL,\n verbose=False\n)\n\n# Merge configurations\nfinal_config = base_config.merge(prod_config)\n```\n\n### Environment Variables\n```bash\nexport TAGENT_MODEL=\"gpt-4o-mini\"\nexport TAGENT_PLANNER_MODEL=\"gpt-4o\"\nexport TAGENT_MAX_ITERATIONS=20\nexport TAGENT_VERBOSE=true\nexport TAGENT_UI_STYLE=institutional\nexport TAGENT_API_KEY=\"your-key\"\n```\n\n## Try It Yourself\n\n```bash\n# Clone the repository\ngit clone https://github.com/yourusername/tagent2\ncd tagent2\n\n# Install in development mode\npip install -e .\n\n# Try without tools (uses LLM knowledge only)\npython -m tagent \"What is the capital of France?\" --model gpt-4o-mini\n\n# Try with tools from an example\npython -m tagent \"Get recent TabNews articles\" --search-dir ./examples/tab_news_analyzer\n\n# Run the TabNews example programmatically\npython examples/tab_news_analyzer/tabnews_code_example.py\n```\n\n## Examples Directory\n\nCheck out the `/examples` folder for real implementations:\n\n- **`tab_news_analyzer/`** - Extract and translate TabNews articles\n- **`travel_planning/`** - Multi-step travel planning agent\n- **`simple_qa/`** - Direct question answering without tools\n\nEach example shows different patterns and use cases.\n\n## What's New in v0.5.0\n\n### Configuration System\n- \u2705 Centralized configuration via `TAgentConfig`\n- \u2705 Environment variable support\n- \u2705 Configuration file support (JSON/YAML)\n- \u2705 Configuration merging and inheritance\n\n### UI System Redesign\n- \u2705 Modular UI architecture with strategy pattern\n- \u2705 **Animated UI**: Matrix-style terminal effects\n- \u2705 **Institutional UI**: Clean structured logging\n- \u2705 Runtime UI style switching\n\n### Developer Experience\n- \u2705 Better error handling and diagnostics\n- \u2705 Improved debugging capabilities\n- \u2705 Type-safe configuration system\n- \u2705 Comprehensive documentation\n\n## Roadmap\n\n- [ ] CrewAI/LangChain/MCP tool adapters\n- [ ] Persistent memory system\n- [ ] Default tool library (web search, file ops)\n- [ ] Optional web interface\n- [ ] Multi-agent orchestration\n- [ ] Tool marketplace/registry\n\n## Contributing\n\n1. Fork the repository\n2. Create a feature branch: `git checkout -b feature/amazing-feature`\n3. Make your changes\n4. Add tests if applicable\n5. Commit: `git commit -m \"Add amazing feature\"`\n6. Push: `git push origin feature/amazing-feature`\n7. Open a Pull Request\n\n## License\n\nMIT License - see [LICENSE](LICENSE) file for details.\n\n## Conclusion\n\nTAgent won't solve all the world's problems, but if you want to create agents without headaches and with code you can understand 6 months later, it might be worth a look.\n\nThe framework is small (<2000 lines), focused, and each component has a clear responsibility. Sometimes simple is better.\n\n---\n\n**Repository:** https://github.com/yourusername/tagent2 \n**License:** MIT \n**Version:** 0.5.0\n\n*If you made it this far and found it interesting, leave a star on GitHub. If you didn't like it, open an issue and complain - feedback is always welcome.*\n",
"bugtrack_url": null,
"license": null,
"summary": "TAgent - Modular AI Agent Framework with Dynamic Tool Discovery",
"version": "0.5.5",
"project_urls": {
"Bug Tracker": "https://github.com/yourusername/tagent2/issues",
"Documentation": "https://github.com/yourusername/tagent2",
"Homepage": "https://github.com/yourusername/tagent2",
"Repository": "https://github.com/yourusername/tagent2.git"
},
"split_keywords": [
"ai",
" agent",
" llm",
" automation",
" framework"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "bea275e5134065070cc4a4ff7773ef79450c63b2ca785f507fb849ae0b69619f",
"md5": "dc210e5b5c257b867acfbed24b396914",
"sha256": "148c0b5eef3d3672e3fe6acaa587845ea94bd41b80c2dc218deab5b8da7cd74a"
},
"downloads": -1,
"filename": "tagent-0.5.5-py3-none-any.whl",
"has_sig": false,
"md5_digest": "dc210e5b5c257b867acfbed24b396914",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 69271,
"upload_time": "2025-07-15T00:22:24",
"upload_time_iso_8601": "2025-07-15T00:22:24.464646Z",
"url": "https://files.pythonhosted.org/packages/be/a2/75e5134065070cc4a4ff7773ef79450c63b2ca785f507fb849ae0b69619f/tagent-0.5.5-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "0d58df71e8a196d176207942c52751bef9d2cd8f380c7735b11287ac10fbf233",
"md5": "dbaec8be4895a7c94ca1597a6d826693",
"sha256": "5fdd2f7b970e83df07a6908c61da98099db31853a9d17becb35d192526eb6e43"
},
"downloads": -1,
"filename": "tagent-0.5.5.tar.gz",
"has_sig": false,
"md5_digest": "dbaec8be4895a7c94ca1597a6d826693",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 2576675,
"upload_time": "2025-07-15T00:22:26",
"upload_time_iso_8601": "2025-07-15T00:22:26.390368Z",
"url": "https://files.pythonhosted.org/packages/0d/58/df71e8a196d176207942c52751bef9d2cd8f380c7735b11287ac10fbf233/tagent-0.5.5.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-15 00:22:26",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "yourusername",
"github_project": "tagent2",
"github_not_found": true,
"lcname": "tagent"
}
