AgentOps

Browser Automation Agent — an MCP server that browses the web, checks conditions, and takes autonomous action. Combined with n8n for notifications and fully Dockerized for portability.

This is not a chatbot. AgentOps is a real agentic automation system: it navigates pages, extracts data, evaluates conditions, sends notifications, and can fill forms autonomously.

Architecture

┌──────────────┐     ┌─────────────────────────────────────────────┐     ┌───────────┐     ┌─────────────┐
│  MCP Client  │────▶│           AgentOps MCP Server               │────▶│ n8n Webhook│────▶│ Email/Slack │
│ (Claude etc) │     │  ┌───────────┐  ┌──────────────────────┐   │     │ (free/host)│     │ Notification │
└──────────────┘     │  │ FastAPI   │  │   Playwright Agent   │   │     └───────────┘     └─────────────┘
                     │  │ Dashboard │──│ Navigate → Extract    │   │
┌──────────────┐     │  │ :8000     │  │ → Screenshot → Form  │   │
│   Browser    │     │  └───────────┘  └──────────────────────┘   │
│ (your app)   │────▶│                                          │     ┌───────────┐
└──────────────┘     │  ┌──────────────────┐  ┌───────────────┐  │────▶│  SQLite   │
                     │  │ Condition Checker │  │   Scheduler   │  │     │  (logs)   │
┌──────────────┐     │  │ price/text/stock  │  │   (periodic)  │  │     └───────────┘
│  Dashboard   │────▶│  │ + Groq LLM fallback│  │               │  │
│  Web UI      │     │  └──────────────────┘  └───────────────┘  │
└──────────────┘     └─────────────────────────────────────────────┘

Flow: MCP Client / Dashboard → MCP Server → Playwright Agent → Condition Check → (if met) n8n Webhook → Notification

Features

5 MCP Tools: check_url_condition, get_check_history, create_scheduled_check, get_agent_activity_log, trigger_form_fill
Condition Types: price_below:X, price_above:X, text_contains:Y, text_absent:Y, stock_available, stock_unavailable, or custom (Groq LLM)
Scheduled + On-Demand Checks: periodic via APScheduler or instant "Run Now"
n8n Integration: webhook-triggered notifications (email, Slack, or any n8n-supported channel)
Full Activity Log: every action logged to SQLite with timestamps and screenshots
Dark/Light Theme Dashboard: real-time updates, screenshot previews, one-click check creation
100% Free Stack: Groq free tier, Playwright (OSS), SQLite, self-hosted n8n

Quick Start (Docker — Recommended)

Prerequisites

Docker and Docker Compose installed

One-Command Start

git clone <your-repo> && cd AgentOps
docker-compose up --build

That's it. Two containers spin up:

Service	URL	Description
AgentOps Dashboard	http://localhost:8000	Web UI, API, MCP tools
n8n Editor	http://localhost:5678	Workflow automation

Set Up n8n Notifications

Open http://localhost:5678 in your browser
Click "Import from File" and upload n8n-workflow.json
The workflow receives webhooks from AgentOps and can send to:
- Email (configure SMTP credentials in n8n — Settings > Credentials > SMTP)
- Slack (add your webhook URL to the Slack node)
- Any channel n8n supports (Discord, Telegram, PagerDuty, etc.)
Toggle the imported workflow to Active (top-right switch)
Test by clicking "Test Webhook" in the AgentOps dashboard header

Quick Start (Manual)

Prerequisites

Python 3.11+
Playwright browsers installed

Install

cd AgentOps
pip install -r requirements.txt
playwright install chromium

Configure (optional)

cp .env.example .env
# Edit .env — add your GROQ_API_KEY (free at console.groq.com) for custom condition evaluation

Run

# Dashboard + API server
python -m uvicorn app.main:app --host 0.0.0.0 --port 8000

# MCP server (stdio transport, for Claude Desktop etc.)
python -m app.mcp_server

To use with Claude Desktop, add to your claude_desktop_config.json:

{
  "mcpServers": {
    "agentops": {
      "command": "python",
      "args": ["-m", "app.mcp_server"],
      "cwd": "/path/to/AgentOps"
    }
  }
}

MCP Tools Reference

Tool	Description	Key Parameters
`check_url_condition`	Navigate to URL, extract data, evaluate condition	`url`, `condition`, `selector?`
`get_check_history`	Get past check results for a URL	`url`
`create_scheduled_check`	Create a periodically-running check	`url`, `condition`, `interval?`, `selector?`
`get_agent_activity_log`	Full activity log with all agent actions	(none)
`trigger_form_fill`	Autonomously fill and submit a web form	`url`, `form_data` (JSON)

Condition Formats

price_below:50          → True if any price on page < 50
price_above:20          → True if any price > 20
text_contains:In Stock  → True if page text contains "In Stock"
text_absent:Sold Out   → True if text does NOT contain "Sold Out"
stock_available         → True if stock signals found
stock_unavailable       → True if out-of-stock signals found
(anything else)         → Evaluated by Groq LLM (requires API key)

Demo Script

Once AgentOps is running, here's what to show:

Open Dashboard at http://localhost:8000 — see 3 pre-seeded demo checks
Click "▶ Run" on any check — watch the activity log populate with navigation, extraction, condition evaluation, and screenshot
Create a New Check — click "+ New Check", enter a books.toscrape.com URL, set a condition, and run it
View Screenshots — click any screenshot in the activity log to see full-size visual proof
Toggle Theme — click the moon/sun icon in the header
Set Up n8n — import the workflow, activate it, and trigger a condition to see a real notification

Example MCP Client Session

You: Check if the book at https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
    has a price below £100. Use the .price_color selector.

→ AgentOps calls check_url_condition(url, "price_below:100", ".price_color")
→ Navigates to page, extracts "£51.77", evaluates: price 51.77 < 100 → MET
→ If n8n is configured, sends notification webhook
→ Returns full result with screenshot path

Demo Safety

All default/seeded checks use books.toscrape.com — a dedicated web scraping practice site. No real e-commerce or business sites are targeted by default.

Project Structure

AgentOps/
├── app/
│   ├── main.py                  # FastAPI entry point, lifespan, seed data
│   ├── mcp_server.py            # MCP server with 5 tools (stdio transport)
│   ├── services.py              # Orchestrator: browser + checker + DB + notifications
│   ├── config.py                # Settings (env vars, defaults)
│   ├── agent/
│   │   ├── browser.py           # Playwright: navigate, extract, screenshot, form fill
│   │   ├── checker.py           # Condition evaluation (built-in + Groq LLM)
│   │   └── scheduler.py         # APScheduler for periodic checks
│   ├── database/
│   │   └── db.py                # SQLite: checks, activity_log, scheduled_checks
│   ├── notifications/
│   │   └── n8n.py               # Webhook caller for n8n
│   └── dashboard/
│       ├── routes.py            # FastAPI API endpoints
│       └── templates/
│           └── index.html        # Dashboard UI (dark/light theme)
├── Dockerfile
├── docker-compose.yml
├── n8n-workflow.json            # Import into n8n
├── requirements.txt
├── .env.example
└── README.md

Free Tier Stack

Component	Tool	Cost
LLM	Groq (Llama-3.3-70b-versatile)	Free
Browser Automation	Playwright (OSS)	Free
Database	SQLite	Free
Workflow/Notifications	n8n (self-hosted)	Free
MCP Protocol	mcp Python SDK	Free
Containerization	Docker	Free

License

MIT