Flyto Core

flyto-core is a debuggable automation engine that provides complete execution tracking, arbitrary step replay, and status snapshot functions. It supports 412 modules covering 78 categories such as browser automation, data processing, and API integration, and can be used through multiple methods such as CLI, MCP server, and HTTP API.

Browser automation Developer tools #Automation engine #Execution tracking #Step replay #Browser automation .Python

rating : 3.5 points

downloads : 5.6K

update time : 2026-03-12

Open Site

What is the flyto-core MCP server?

The flyto-core MCP server is an implementation of the Model Context Protocol (MCP), which exposes 412 automation modules of flyto-core as tools to AI assistants (such as Claude, Cursor, and Windsurf). Through this server, AI can directly call modules for browser automation, file operations, data processing, etc., without writing complex code.

How to use the flyto-core MCP server?

After installing flyto-core, configure your AI client (such as Claude Desktop) to connect to the MCP server. The AI assistant can then directly access all modules and execute complex automated tasks through natural language instructions, such as taking website screenshots, data analysis, and file processing.

Applicable scenarios

Suitable for scenarios that require AI assistance to complete automated tasks: • Data analysts need to extract data from websites. • Developers need automated testing and monitoring. • Content creators need to process images and files in batches. • Operation and maintenance personnel need automated deployment and monitoring. • Researchers need to collect and analyze network data.

Main features

MCP protocol support

Fully compatible with the Model Context Protocol, it can be seamlessly integrated with AI clients such as Claude Desktop, Cursor, and Windsurf.

Access to 412 modules

All 412 automation modules are exposed through MCP, and AI can directly call tools such as browsers, files, APIs, and data processing.

Natural language interaction

AI understands user needs through natural language and automatically selects appropriate modules and parameters to execute tasks.

Complete execution tracking

All operations executed through MCP have complete execution records, including input, output, time consumption, and status.

Step replay support

It supports re - execution from any step. When a task fails midway, there is no need to start from the beginning.

Advantages

No programming knowledge required: Complex automated tasks can be completed through natural language.

One - stop solution: Covers 78 categories such as browsers, files, APIs, and data processing.

Traceable and debuggable: Each step has a complete record, which is convenient for troubleshooting.

Flexible integration: Supports multiple AI clients and workflow tools.

Community - driven: Continuously updated module library and recipes.

Limitations

Requires AI client support: Must use an AI tool that supports the MCP protocol.

Network dependency: Some modules require a network connection.

Learning curve: Need to understand basic concepts and command structures.

Resource consumption: Tasks such as browser automation require more system resources.

How to use

Install flyto-core

Install the flyto-core package via pip. If browser functionality is needed, install the browser extension.

Configure the AI client

Add the MCP server configuration to your AI client (such as Claude Desktop).

Start the MCP server

Run the MCP server, and the AI client will automatically connect and obtain the list of available tools.

Use tools through AI

In the AI chat interface, describe your needs in natural language, and the AI will automatically call the corresponding flyto-core modules.

Usage examples

Website performance analysis

The AI assistant helps users analyze website performance, including loading time, core Web metrics, etc.

Data extraction and conversion

Extract data from web pages and convert it into the required format.

Automated screenshot

Generate desktop and mobile screenshots for websites.

Batch file processing

Process image or document files in batches.

Frequently Asked Questions

Do I need programming knowledge to use flyto-core MCP?

Which AI clients are supported?

What should I do if the execution fails?

How to add custom modules?

How to ensure data security?

Do I need to run the MCP server all the time?

Related resources

flyto-core GitHub repository

Source code, issue tracking, and contribution guidelines

MCP protocol documentation

Official documentation of the Model Context Protocol

Module catalog

Complete list and description of 412 modules

Recipe examples

More than 30 predefined workflow examples

Module development guide

How to develop and contribute new modules

🚀 flyto-core

A debuggable automation engine. Trace every step. Replay from any point.

🚀 Quick Start

Try in 30 seconds

pip install flyto-core[browser] && playwright install chromium
flyto recipe competitor-intel --url https://github.com/pricing

  Step  1/12  browser.launch         ✓      420ms
  Step  2/12  browser.goto           ✓    1,203ms
  Step  3/12  browser.evaluate       ✓       89ms
  Step  4/12  browser.screenshot     ✓    1,847ms  → saved intel-desktop.png
  Step  5/12  browser.viewport       ✓       12ms  → 390×844
  Step  6/12  browser.screenshot     ✓    1,621ms  → saved intel-mobile.png
  Step  7/12  browser.viewport       ✓        8ms  → 1280×720
  Step  8/12  browser.performance    ✓    5,012ms  → Web Vitals captured
  Step  9/12  browser.evaluate       ✓       45ms
  Step 10/12  browser.evaluate       ✓       11ms
  Step 11/12  file.write             ✓        3ms  → saved intel-report.json
  Step 12/12  browser.close          ✓       67ms

  ✓ Done in 10.3s — 12/12 steps passed

Screenshots captured. Performance metrics extracted. JSON report saved. Every step traced.

✨ Features

What happens when step 8 fails?

With a shell script you re-run the whole thing. With flyto-core:

flyto replay --from-step 8

Steps 1–7 are instant. Only step 8 re-executes. Full context preserved.

3 recipes to try now

# Competitive pricing: screenshots + Web Vitals + JSON report
flyto recipe competitor-intel --url https://competitor.com/pricing

# Full site audit: SEO + accessibility + performance
flyto recipe full-audit --url https://your-site.com

# Web scraping → CSV export
flyto recipe scrape-to-csv --url https://news.ycombinator.com --selector ".titleline a"

Every recipe is traced. Every run is replayable. See all 32 recipes →

📦 Installation

pip install flyto-core            # Core engine + CLI + MCP server
pip install flyto-core[browser]   # + browser automation (Playwright)
playwright install chromium        # one-time browser setup

💻 Usage Examples

The 85-line problem

Here's what competitive pricing analysis looks like in Python:

	Python	flyto-core
Code Length	85 lines	12 steps
Traceability	No trace. No replay. No timing. If step 5 fails, re-run everything.	Full trace. Replay from any step. Per-step timing. Every run is debuggable.

Python

import asyncio, json, time
from playwright.async_api import async_playwright

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto("https://competitor.com/pricing")

        # Extract pricing
        prices = await page.evaluate("""() => {
            const cards = document.querySelectorAll(
              '[class*="price"]'
            );
            return Array.from(cards).map(
              c => c.textContent.trim()
            );
        }""")

        # Desktop screenshot
        await page.screenshot(
            path="desktop.png", full_page=True
        )

        # Mobile
        await page.set_viewport_size(
            {"width": 390, "height": 844}
        )
        await page.screenshot(
            path="mobile.png", full_page=True
        )

        # Performance
        perf = await page.evaluate("""() => {
            const nav = performance
              .getEntriesByType('navigation')[0];
            return {
              ttfb: nav.responseStart,
              loaded: nav.loadEventEnd
            };
        }""")

        # Save report
        report = {
            "prices": prices,
            "performance": perf,
        }
        with open("report.json", "w") as f:
            json.dump(report, f, indent=2)

        await browser.close()

asyncio.run(main())

flyto-core

name: Competitor Intel
steps:
  - id: launch
    module: browser.launch
  - id: navigate
    module: browser.goto
    params: { url: "{{url}}" }
  - id: prices
    module: browser.evaluate
    params:
      script: |
        JSON.stringify([
          ...document.querySelectorAll(
            '[class*="price"]'
          )
        ].map(e => e.textContent.trim()))
  - id: desktop_shot
    module: browser.screenshot
    params: { path: desktop.png, full_page: true }
  - id: mobile
    module: browser.viewport
    params: { width: 390, height: 844 }
  - id: mobile_shot
    module: browser.screenshot
    params: { path: mobile.png, full_page: true }
  - id: perf
    module: browser.performance
  - id: save
    module: file.write
    params:
      path: report.json
      content: "${prices.result}"
  - id: close
    module: browser.close

🔧 Technical Details

Engine Features

Execution Trace — structured record of every step: input, output, timing, status
Replay — re-execute from any step with the original (or modified) context
Breakpoints — pause execution at any step, inspect state, resume
Evidence Snapshots — full state before and after each step boundary
Data Lineage — track data flow across steps, build dependency graphs
Timeout Guard — configurable workflow-level and per-step timeout protection

412 Modules, 78 Categories

Category	Count	Examples
`browser.*`	38	launch, goto, click, extract, screenshot, fill forms, wait
`flow.*`	24	switch, loop, branch, parallel, retry, circuit breaker, rate limit
`array.*`	15	filter, sort, map, reduce, unique, chunk, flatten
`string.*`	11	reverse, uppercase, split, replace, trim, slugify, template
`api.*`	11	OpenAI, Anthropic, Gemini, Notion, Slack, Telegram
`object.*`	10	keys, values, merge, pick, omit, get, set, flatten
`image.*`	9	resize, convert, crop, rotate, watermark, OCR, compress
`data.*`	8	json/xml/yaml/csv parse and generate
`file.*`	8	read, write, copy, move, delete, exists, edit, diff
`stats.*`	8	mean, median, percentile, correlation, standard deviation
`validate.*`	7	email, url, json, phone, credit card
`docker.*`	6	run, ps, logs, stop, build, inspect
`archive.*`	6	zip create/extract, tar create/extract, gzip, gunzip
`math.*`	6	calculate, round, ceil, floor, power, abs
`k8s.*`	5	get_pods, apply, logs, scale, describe
`crypto.*`	4	AES encrypt/decrypt, JWT create/verify
`network.*`	4	ping, traceroute, whois, port scan
`pdf.*`	4	parse, extract text, merge, compress
`aws.s3.*`	4	upload, download, list, delete
`google.*`	4	Gmail send/search, Calendar create/list events
`cache.*`	4	get, set, delete, clear (memory + Redis)
`ssh.*`	3	remote exec, SFTP upload, SFTP download
`git.*`	3	clone, commit, diff
`sandbox.*`	3	execute Python, Shell, JavaScript
`dns.*`	1	DNS lookup (A, AAAA, MX, CNAME, TXT, NS)
`monitor.*`	1	HTTP health check with SSL cert verification

See the Full Module Catalog for every module, parameter, and description.

How is this different?

	Playwright / Selenium	Shell scripts	flyto-core
Step 8 fails	Re-run everything	Re-run everything	`flyto replay --from-step 8`
What happened at step 3?	Add print(), re-run	Add echo, re-run	Full trace: input, output, timing
Browser + API + file I/O	Write glue code	3 languages	All built-in
Share with team	"Clone my repo"	"Clone my repo"	`pip install flyto-core`
Run in CI	Wrap in pytest/bash	Fragile	`flyto run workflow.yaml`

📚 Documentation

How to Use

CLI — run workflows from the terminal

```bash # Run a built-in recipe flyto recipe site-audit --url https://example.com

Run your own YAML workflow

flyto run my-workflow.yaml

List all recipes

flyto recipes

</details>

<details>
<summary><b>MCP Server</b> — for Claude Code, Cursor, Windsurf</summary>
```bash
pip install flyto-core
claude mcp add flyto-core -- python -m core.mcp_server

Or add to your MCP config:

{
  "mcpServers": {
    "flyto-core": {
      "command": "python",
      "args": ["-m", "core.mcp_server"]
    }
  }
}

Your AI gets all modules as tools.

HTTP API — for integrations and remote execution

```bash pip install flyto-core[api] flyto serve # ✓ flyto-core running on 127.0.0.1:8333 ``` | Endpoint | Purpose | |----------|---------| | `POST /v1/workflow/run` | Execute workflow with evidence + trace | | `POST /v1/workflow/{id}/replay/{step}` | Replay from any step | | `POST /v1/execute` | Execute a single module | | `GET /v1/modules` | Discover all modules | | `POST /mcp` | MCP Streamable HTTP transport |

Python API — for programmatic use

```python import asyncio from core.modules.registry import ModuleRegistry

async def main(): result = await ModuleRegistry.execute( "string.reverse", params={"text": "Hello"}, context={} ) print(result) # {"ok": True, "data": {"result": "olleH"}}

asyncio.run(main())

</details>

### 30+ Built-in Recipes
No code required — every recipe is a YAML workflow template:
```bash
flyto recipes                  # List all recipes

# Audit & Testing
flyto recipe full-audit       --url https://example.com
flyto recipe competitor-intel --url https://github.com/pricing
flyto recipe site-audit       --url https://example.com
flyto recipe web-perf         --url https://example.com
flyto recipe login-test       --url https://myapp.com/login --username user --password pass --success_selector .dashboard
flyto recipe form-fill        --url https://myapp.com/form --data '{"email":"test@example.com"}'

# Browser Automation
flyto recipe screenshot        --url https://example.com
flyto recipe responsive-report --url https://example.com
flyto recipe page-to-pdf       --url https://example.com
flyto recipe visual-snapshot   --url https://example.com
flyto recipe webpage-archive   --url https://example.com
flyto recipe scrape-page       --url https://example.com --selector h1
flyto recipe scrape-links      --url https://example.com
flyto recipe scrape-table      --url https://en.wikipedia.org/wiki/YAML --selector .wikitable
flyto recipe stock-price       --symbol AAPL

# Data & Image
flyto recipe ocr               --input scan.png
flyto recipe csv-to-json       --input data.csv
flyto recipe image-resize      --input photo.jpg --width 800
flyto recipe image-convert     --input photo.png --format webp

# Network & DevOps
flyto recipe port-scan         --host example.com
flyto recipe whois             --domain example.com
flyto recipe monitor-site      --url https://myapp.com
flyto recipe docker-ps
flyto recipe git-changelog

# Integrations
flyto recipe scrape-to-slack   --url https://example.com --selector h1 --webhook $SLACK_URL
flyto recipe github-issue      --url https://example.com --owner me --repo my-app --title "Bug" --token $GITHUB_TOKEN

Each recipe is a YAML workflow template. Run flyto recipe <name> --help for full options. See docs/RECIPES.md for full documentation.

Write Your Own Workflows

Recipes are just YAML files. Write your own:

name: price-monitor
steps:
  - id: open
    module: browser.launch
    params: { headless: true }

  - id: page
    module: browser.goto
    params: { url: "https://competitor.com/pricing" }

  - id: prices
    module: browser.evaluate
    params:
      script: |
        JSON.stringify([...document.querySelectorAll('.price')].map(e => e.textContent))

  - id: save
    module: file.write
    params: { path: "prices.json", content: "${prices.result}" }

  - id: close
    module: browser.close

flyto run price-monitor.yaml

Every run produces an execution trace and state snapshots. If step 3 fails, replay from step 3 — no re-running the whole thing.

For Module Authors

from core.modules.registry import register_module
from core.modules.schema import compose, presets

@register_module(
    module_id='string.reverse',
    version='1.0.0',
    category='string',
    label='Reverse String',
    description='Reverse the characters in a string',
    params_schema=compose(presets.INPUT_TEXT(required=True)),
    output_schema={'result': {'type': 'string', 'description': 'Reversed string'}},
)
async def string_reverse(context):
    text = str(context['params']['text'])
    return {'ok': True, 'data': {'result': text[::-1]}}