Metadata-Version: 2.4
Name: agentapps
Version: 0.2.22
Summary: AgentApps — A flexible multi-agent orchestration framework with visual Flow Builder
Home-page: https://www.agentappsai.com
Author: AgentApps Team
Author-email: mannankhanabdul@googlemail.com
Project-URL: Bug Reports, https://github.com/91abdul/agentapps/issues
Project-URL: Source, https://github.com/91abdul/agentapps
Project-URL: Documentation, https://github.com/91abdul/agentapps#readme
Keywords: agents,ai,llm,orchestration,multi-agent,openai,flow-builder,visual,gemini,grok
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.8
Description-Content-Type: text/markdown
Requires-Dist: openai
Requires-Dist: ddgs
Requires-Dist: beautifulsoup4
Requires-Dist: requests
Requires-Dist: fastapi>=0.100.0
Requires-Dist: uvicorn[standard]>=0.24.0
Requires-Dist: python-multipart
Requires-Dist: rank-bm25
Requires-Dist: rapidfuzz
Requires-Dist: gdown
Requires-Dist: pymupdf
Requires-Dist: python-docx
Requires-Dist: cryptography
Requires-Dist: pdfplumber
Requires-Dist: openpyxl
Requires-Dist: msal
Requires-Dist: pyodbc
Provides-Extra: gemini
Requires-Dist: google-genai; extra == "gemini"
Provides-Extra: ssl
Requires-Dist: cryptography; extra == "ssl"
Provides-Extra: all
Requires-Dist: google-genai; extra == "all"
Requires-Dist: cryptography; extra == "all"
Provides-Extra: dev
Requires-Dist: pytest; extra == "dev"
Requires-Dist: black; extra == "dev"
Requires-Dist: flake8; extra == "dev"
Requires-Dist: mypy; extra == "dev"
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: keywords
Dynamic: project-url
Dynamic: provides-extra
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary

# AgentApps

A flexible multi-agent orchestration framework for building intelligent agent applications with a visual Flow Builder.

---

## Features

🤖 **Simple Agent Creation** — Clean, intuitive agent setup  
👥 **Team Collaboration** — Multiple agents working together  
🔄 **Sequential Workflows** — Automatic multi-step execution  
🛠️ **Built-in Tools** — Web search, scraping, calculations  
🎯 **Custom Tools** — Easy 3rd-party integrations (Jira, Slack, GitHub, SMTP and more)  
📊 **Streaming Support** — Real-time responses  
🔍 **Web Search** — DuckDuckGo integration  
🌐 **Web Scraping** — Extract content from any URL  
🌟 **Multi-Model Support** — OpenAI, Google Gemini, xAI Grok, Ollama (local)  
🗂️ **Platform Tables** — Built-in structured data storage  
⏰ **Triggers & Scheduler** — Run agents on a schedule or via webhook  
🐚 **Shell Tool** — Execute server commands from agents (opt-in)  
🔐 **Role-Based Access** — Admin, Editor, Operator, Viewer roles  
🔑 **SSO / Microsoft Azure AD** — Single Sign-On support  
🏗️ **AI Builder** — Describe an agent in plain English and it builds itself  
🌍 **Portal** — End-user chat interface for your deployed agents  

---

## Links

- **GitHub:** https://github.com/91Abdul/agentapps  
- **PyPI:** https://pypi.org/project/agentapps  
- **Website:** https://www.agentappsai.com  
- **Issues:** https://github.com/91Abdul/agentapps/issues  
- **Discord:** https://discord.gg/xAUYb2vujP  
- **LinkedIn Group:** https://www.linkedin.com/groups/14471903/  
- **Support:** ak@agentappsai.com  

---

## Installation

```bash
pip install agentapps
```

---

## Quick Start — Flow Builder UI

```bash
agentapps-flow
```

This starts the server and automatically opens the visual Flow Builder in your browser at `http://localhost:7860`.

```bash
# Custom port
agentapps-flow --port 8080

# Don't open browser automatically
agentapps-flow --no-browser

# Dev mode with hot-reload
agentapps-flow --reload
```

---

## Secure Login

### 1. CLI flag
```bash
agentapps-flow --password mysecretpassword
```

### 2. Environment variable (recommended for servers)
```bash
export AGENTAPPS_PASSWORD=mysecretpassword
agentapps-flow
```

### 3. Auto-generated password
If no password is set, one is auto-generated and printed to the console:

```
╔══════════════════════════════════════════════╗
║   🔑 Auto-generated password:                ║
║      xK9mP2nQvR4sT7uW                        ║
╚══════════════════════════════════════════════╝
```

> Passwords are stored as secure hashes — never in plaintext.

---

## Shell Tool (opt-in)

Enable agents to run shell commands on the server (Windows cmd, Mac/Linux bash, PowerShell):

```bash
agentapps-flow --enable-shell
```

Or via environment variable:
```bash
AGENTAPPS_ENABLE_SHELL=true agentapps-flow
```

Optionally restrict the working directory:
```bash
AGENTAPPS_SHELL_DIR=/path/to/scripts agentapps-flow --enable-shell
```

> Shell tool is **disabled by default**. All commands are logged and protected by a blocklist. Use with care on shared servers.

---

## Supported Models

| Provider | Model IDs |
|---|---|
| OpenAI | `gpt-4o`, `gpt-4-turbo`, `gpt-3.5-turbo` |
| Google Gemini | `gemini-2.0-flash`, `gemini-1.5-pro` |
| xAI Grok | `grok-3`, `grok-3-mini` |
| Ollama (local) | Any locally served model via `http://localhost:11434` |
| Azure OpenAI | Any Azure-hosted OpenAI deployment |

---

## Quick Start with OpenAI

```python
from agentapps import Agent
from agentapps.model import OpenAIChat
from agentapps.tools import SearchSummaryTool

agent = Agent(
    name="Research Assistant",
    role="Search and analyze information",
    model=OpenAIChat(id="gpt-4o", api_key="your-openai-key"),
    tools=[SearchSummaryTool()],
    instructions=["Always include sources"],
    show_tool_calls=True
)

agent.print_response("What is the latest news about AI?")
```

Get an OpenAI API key: https://platform.openai.com/api-keys

---

## Quick Start with Gemini

```python
from agentapps import Agent
from agentapps.model import GeminiChat
from agentapps.tools import SearchSummaryTool

agent = Agent(
    name="Research Assistant",
    role="Search and analyze information",
    model=GeminiChat(id="gemini-2.0-flash-exp", api_key="your-google-api-key"),
    tools=[SearchSummaryTool()],
    instructions=["Always include sources"],
    show_tool_calls=True
)

agent.print_response("What is the latest news about AI?")
```

Get a Gemini API key: https://makersuite.google.com/app/apikey

---

## Quick Start with Grok xAI

```python
from agentapps import Agent
from agentapps.model import GrokChat
from agentapps.tools import SearchSummaryTool

agent = Agent(
    name="Research Assistant",
    role="Search and analyze information",
    model=GrokChat(id="grok-3-mini", api_key="your-xai-api-key"),
    tools=[SearchSummaryTool()],
    instructions=["Always include sources"],
    show_tool_calls=True
)

agent.print_response("What is the latest news about AI?")
```

Get a Grok API key: https://console.x.ai

---

## Available Tools

### SearchSummaryTool
Search the web and get detailed snippets:

```python
from agentapps.tools import SearchSummaryTool

agent = Agent(
    name="Searcher",
    model=OpenAIChat(id="gpt-4o", api_key="key"),
    tools=[SearchSummaryTool()]
)
```

### WebScraperTool
Scrape content from URLs:

```python
from agentapps.tools import WebScraperTool

agent = Agent(
    name="Scraper",
    model=OpenAIChat(id="gpt-4o", api_key="key"),
    tools=[WebScraperTool()]
)
```

### CalculatorTool
Perform calculations:

```python
from agentapps.tools import CalculatorTool

agent = Agent(
    name="Calculator",
    model=OpenAIChat(id="gpt-4o", api_key="key"),
    tools=[CalculatorTool()]
)
```

---

## Team Agents

Create teams that work together sequentially:

```python
from agentapps import Agent
from agentapps.model import OpenAIChat
from agentapps.tools import SearchSummaryTool, WebScraperTool

search_agent = Agent(
    name="Search Agent",
    role="Search the web",
    model=OpenAIChat(id="gpt-4o", api_key="your-key"),
    tools=[SearchSummaryTool()]
)

scraper_agent = Agent(
    name="Scraper Agent",
    role="Read web pages",
    model=OpenAIChat(id="gpt-4o", api_key="your-key"),
    tools=[WebScraperTool()]
)

team = Agent(
    team=[search_agent, scraper_agent],
    instructions=[
        "First, search for relevant URLs",
        "Then, scrape content from those URLs",
        "Finally, provide a comprehensive answer"
    ],
    show_tool_calls=True
)

team.print_response("Research NVIDIA's latest AI developments")
```

---

## Custom Tools

Create your own tools easily:

```python
from agentapps import Tool

class WeatherTool(Tool):
    def __init__(self):
        super().__init__(
            name="get_weather",
            description="Get weather for a city"
        )

    def execute(self, city: str) -> str:
        return f"Weather in {city}: Sunny, 72°F"

    def get_parameters(self):
        return {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }

agent = Agent(
    name="Weather Agent",
    model=OpenAIChat(id="gpt-4o", api_key="key"),
    tools=[WeatherTool()]
)
```

You can also register custom tools via the Flow Builder UI — no restart required.

---

## Examples

### Stock Analysis
```python
agent = Agent(
    name="Stock Analyst",
    role="Analyze stocks",
    model=OpenAIChat(id="gpt-4o", api_key="key"),
    tools=[SearchSummaryTool()],
    instructions=["Include price targets and analyst ratings"]
)

agent.print_response("Analyze NVDA stock with latest news and recommendations")
```

### Research Team
```python
research_team = Agent(
    team=[search_agent, scraper_agent],
    instructions=[
        "Search for academic sources",
        "Read full articles",
        "Provide a comprehensive summary with citations"
    ]
)

research_team.print_response("What are the latest breakthroughs in quantum computing?")
```

---

## API Reference

### Agent

```python
Agent(
    name: str = "Agent",
    role: str = "General Assistant",
    model: Model = None,
    tools: List[Tool] = None,
    instructions: List[str] = None,
    team: List[Agent] = None,
    show_tool_calls: bool = False,
    markdown: bool = False,
    temperature: float = None
)
```

### Methods

| Method | Description |
|---|---|
| `run(message, stream=False)` | Execute agent |
| `print_response(message, stream=False)` | Print response to console |
| `clear_history()` | Clear conversation history |
| `add_tool(tool)` | Add a tool dynamically |
| `get_info()` | Get agent information |

---

## Role-Based Access Control

The platform supports four roles assignable per user:

| Role | Description |
|---|---|
| **Admin** | Full access — users, settings, SSO, shell tool |
| **Editor** | Build and run — create/edit agents, tools, schedules |
| **Operator** | Run only — use agents via portal, view reports and approvals |
| **Viewer** | Read only — view projects, tables, reports |

Manage users and assign roles from the **Admin → Users** section in the Flow Builder.

---

## Triggers & Scheduler

Run agents automatically on a schedule or via external webhook:

- **Scheduler** — run agents every N minutes, hourly, daily, or weekly
- **Webhook** — trigger agents via HTTP from any external service (Jira, Zapier, Slack, etc.)

Manage triggers from the **Triggers** tab or ask the AI Builder to add one for you.

---

## HTTPS / SSL

Secure HTTPS is required for production webhooks.

### Option 1 — Auto self-signed certificate (easiest)
```bash
pip install cryptography
agentapps-flow --ssl-self-signed
```

### Option 2 — Bring your own certificate (Let's Encrypt / purchased)
```bash
agentapps-flow --ssl-cert /path/to/cert.pem --ssl-key /path/to/key.pem
```

Getting a free Let's Encrypt certificate:
```bash
pip install certbot
certbot certonly --standalone -d yourdomain.com

agentapps-flow \
  --ssl-cert /etc/letsencrypt/live/yourdomain.com/fullchain.pem \
  --ssl-key  /etc/letsencrypt/live/yourdomain.com/privkey.pem
```

### Option 3 — Standard HTTPS port (443)
```bash
agentapps-flow --port 443 --ssl-self-signed
```

> On Linux/macOS, binding to port 443 requires root or sudo. Consider using a reverse proxy (nginx, Caddy) for production.

### Using with ngrok (recommended for local webhooks)
```bash
# Terminal 1
agentapps-flow

# Terminal 2
ngrok http 7860
```

Use the `https://xxxx.ngrok-free.app` URL as your webhook base URL.

### Webhook URL format
```
https://your-domain.com/webhook/<project-name>?token=<bearer-token>
```

Tokens are generated in the Flow Builder under ☰ Menu → 🔗 Webhooks.

---

## All CLI Flags

| Flag | Default | Description |
|---|---|---|
| `--port` | `7860` | Port to listen on |
| `--host` | `0.0.0.0` | Host to bind to |
| `--no-browser` | off | Don't auto-open browser |
| `--reload` | off | Hot-reload on file changes (dev mode) |
| `--password` | — | Set UI login password |
| `--ssl-self-signed` | off | Auto-generate self-signed certificate |
| `--ssl-cert` | — | Path to SSL certificate `.pem` file |
| `--ssl-key` | — | Path to SSL private key `.pem` file |
| `--enable-shell` | off | Enable ShellTool (execute shell commands via agents) |

---

## Requirements

- Python >= 3.8
- An API key from OpenAI, Google Gemini, xAI Grok — or a local Ollama instance

### Installed automatically with `pip install agentapps`:

- `openai` — OpenAI / Grok API client
- `ddgs` — DuckDuckGo search
- `beautifulsoup4` — HTML parsing
- `google-genai` — Google Gemini client
- `requests` — HTTP requests

---

## License

MIT License

---

## Contributing

Contributions welcome! Please feel free to submit a Pull Request on [GitHub](https://github.com/91Abdul/agentapps).
