pipulate MCP工具

💡 What Can You Actually Build?

Real examples of what people create with Pipulate:

The Bedrock Architecture: Why We Don't Use Docker

The Prediction (2025): The "Container Era" is a transition, not a destination. We are currently shipping entire user-space operating systems (Docker images) just to run a single binary. It is inefficient, opaque, and fundamentally insecure.

Pipulate bets on the "Derivation Era."

In this future, we don't ship containers; we ship formulas. We ship the mathematical derivation that results in the software.

• The Old Way (Docker): "Here is a 500MB blob of binary data. Trust me, it works."
• The Bedrock Way (Nix): "Here is a 2KB text file (flake.nix). If you evaluate it, you will get the exact same bit-for-bit result I have."

Why this matters for AI: AI agents cannot "troubleshoot" why libc is missing in a random Ubuntu container. AI needs determinism. It needs a world where Input + Code = Output, every single time, without exception. Nix is the only OS that speaks the language of AI: Pure Functional Logic.

• Nix Flakes: Manages dependencies and creates reproducible environments, ensuring consistency across developers and operating systems, with optional CUDA support. Do you remember normalize.css from the wild web that made all browsers show webpages the same? Nix is normalized Linux so all Macs, Windows and other Linuxes run your distributed app exactly the same.

```text .--. ___________ _ http://levinix.com ,--./,-. |o_o | | | | | | _____ ()_ __ () __ / # \ |:/ | | | | | | / \ \ / / | '_ \| \ \/ / | | // \ \ |___|| | || /\ V /| | | | | |> < \ / (| | ) | | | |\| \/ ||| ||//\\ ._,._,' /'\_ _/\ | | | \)=(/ |___|___|

How to Install Pipulate

PATH 1: Quick Start — Universal Installation (Recommended)

This is the fastest and most universal way to install Pipulate. It has the fewest dependencies and works on any modern Mac, Linux system, or Windows with WSL.

    📦 Your Machine            🔧 Add Foundation       🚀 Complete Environment
         Today                       with Nix                 Ready to Go!

    ┌─────────────┐             ┌─────────────┐             ┌─────────────┐
    │ Sad Computer│    Step 1   │   🏗️ Nix    │    Step 2   │ 🎯 Pipulate │
    │   Without   │ ──────────► │ Foundation  │ ──────────► │   + AI +    │
    │    Nix😢    │             │  Installed  │             │   Jupyter   │
    └─────────────┘             └─────────────┘             └─────────────┘
                                                                    │
                                                             Step 3 │
                                                                    ▼
                                                             ┌─────────────┐
                                                             │ 🌐 Browser  │
                                                             │    Opens    │
                                                             │Automatically│
                                                             └─────────────┘

    Simple as 1-2-3! No Docker, no build steps, works with or without cloud services.
Everything runs locally with complete flexibility and control.

The installation procedures labeled "Quick Start Guide" and the main installation path are both the same. Follow the instructions at the top of this page.

The Big Reset (If Necessary):

⚠️ Warning: This command is destructive. It will permanently delete your project folder, including any data you have created or downloaded. Use it only if you want a completely fresh start.

rm -rf ~/TestProject
curl -L https://pipulate.com/install.sh | bash -s TestProject
cd ~/TestProject
./run

Wait for BOTH TABS to auto-open in your browser.

Installation Process Deep Dive

Here's what happens behind the scenes during the "magic cookie" installation:

User runs assets/installer/install.sh (via curl)           Nix Flake Activation & Transformation
┌──────────────────────────────┐         ┌────────────────────────────────────────────┐
│ 1. Download install.sh       │         │ 5. User runs './run' ('nix develop')       │
│ 2. Download ZIP from GitHub  │         │ 6. Flake detects non-git directory         │
│ 3. Extract ZIP to ~/AppName  │         │ 7. Flake clones repo to temp dir           │
│ 4. Download ROT13 SSH key    │         │ 8. Preserves whitelabel.txt, .ssh, .venv   │
│    to .ssh/rot               │         │ 9. Moves git repo into place               │
└─────────────┬────────────────┘         │10. Sets up SSH key for git                 │
              │                          │11. Transforms into git repo                │
              ▼                          │12. Enables auto-update via git pull        │
      ┌─────────────────────────────────────────────────────────────────────────────┐
      │ Result: Fully functional, auto-updating, git-based Pipulate installation    │
      └─────────────────────────────────────────────────────────────────────────────┘

Developer Setup & Environment Notes

Nix Environment Activation: Always run ./run (a.k.a. nix develop) from the ~/pipulate directory before running any project commands (python server.py, pip install, etc.) in a new terminal. This ensures you are using the correct dependencies defined in flake.nix.

Interactive vs. Quiet Shell:

Standard Shell: ./run (same as nix develop or nix develop .#default) runs the startup script (run-script defined in flake.nix) with welcome messages and service startup. Ideal for general use.

Quiet Shell: nix develop .#quiet activates the Nix environment without running the full startup script or launching services automatically. It only sets up paths and installs pip requirements. Use this for: - Running specific commands without starting the servers (e.g., nix develop .#quiet --command python -c "import pandas"). - Debugging or interacting with AI assistants where verbose startup output is undesirable. - Manually running run-server or run-jupyter (scripts placed in .venv/bin by the shellHook).

Dependencies: System-level dependencies (Python version, libraries like gcc, zlib) are managed by flake.nix. Python package dependencies are managed by pip using requirements.txt within the Nix-provided environment.

Source of Truth: The flake.nix file is the definitive source for the development environment setup.

--------------------------------------------------------------------------------

Quick Start: Be Running in 5 Minutes

Want to skip the philosophy and just see what this does? Paste this into your terminal:

curl -fsSL https://pipulate.com/install.sh | bash

Note: Nix creates a perfectly reproducible environment, like Docker but more integrated. The first setup might take a few minutes to download dependencies, but subsequent launches are fast.

```bash

Integrated Data Science Environment

Jupyter Notebooks run alongside the FastHTML server, allowing developers to prototype workflows in a familiar environment before porting them to Pipulate's step-based interface for end-users. The same Python virtual environment (.venv) is shared, and ad-hoc package installation is supported. If you're using Cursor, VSCode or Windsurf, set your Ctrl+Shift+P "Python: Set Interpreter" to "Enter Interpreter Path" ./pipulate/.venv/bin/python. You might have to adjust based on the folder you use as your workspace. But then you'll have a Python environment unified between Cursor, JupyterLab and Pipulate.

      ┌──────────────────┐    ┌──────────────────┐
      │   Jupyter Lab    │    │    FastHTML      │
      │   Notebooks      │    │     Server       │
      │ ┌──────────┐     │    │  ┌──────────┐    │
      │ │ Cell 1   │     │    │  │ Step 1   │    │
      │ │          │     │--->│  │          │    │
      │ └──────────┘     │    │  └──────────┘    │
      │ ┌──────────┐     │    │  ┌──────────┐    │
      │ │ Cell 2   │     │    │  │ Step 2   │    │
      │ │          │     │--->│  │          │    │
      │ └──────────┘     │    │  └──────────┘    │
      │  localhost:8888  │    │  localhost:5001  │
      └──────────────────┘    └──────────────────┘

From Flask to FastAPI to FastHTML

This is not your father's Python web framework. HTMX changes everything — a marriage made in heaven between Python and the Web, finally turning Python into a first-class citizen for web development. In many use cases such as this one, Python is even preferable to JavaScript in the way it blends Python's formidable ecosystem of packages with workflows.

The Evolution: Flask → FastAPI → FastHTML

The revolution isn't just another framework — it's eliminating the template layer entirely:

    🍶 FLASK ERA              🚀 FASTAPI ERA            🌐 FASTHTML ERA
    ═══════════════           ═══════════════           ══════════════════

    ┌─────────────┐           ┌─────────────┐           ┌─────────────┐
    │   Python    │           │   Python    │           │   Python    │
    │  Functions  │           │  Functions  │           │  Functions  │
    └──────┬──────┘           └──────┬──────┘           └──────┬──────┘
           │                         │                         │
           ▼                         ▼                         ▼
    ┌─────────────┐           ┌─────────────┐           ┌─────────────┐
    │   Jinja2    │           │  Pydantic   │           │    HTMX     │◄─ Over-the-wire
    │  Templates  │           │   Models    │           │  Fragments  │   HTML targeting
    └──────┬──────┘           └──────┬──────┘           └──────┬──────┘   DOM elements
           │                         │                         │
           ▼                         ▼                         ▼
    ┌─────────────┐           ┌─────────────┐           ┌─────────────┐
    │    HTML     │           │    JSON     │           │    HTML     │
    │   Response  │           │   Response  │           │  Elements   │
    └─────────────┘           └─────────────┘           └─────────────┘
           │                         │                         │
           ▼                         ▼                         ▼
    🌐 Full Page Reload     📱 Frontend Framework      🎯 DOM Element Updates
                               (React/Vue/Angular)        def Div() = <div>
                                                          def Button() = <button>

    Template files needed    JSON ↔ HTML conversion     Python functions ARE
    Separate languages       Client-side complexity     the template language!

The FastHTML Breakthrough: Python function names directly become HTML elements, eliminating templates and making the server the single source of truth for UI state.

• HTMX: Enables dynamic, interactive UIs directly in HTML via attributes, minimizing the need for custom JavaScript. Pipulate uses it for server-rendered HTML updates — over the wire HTML-fragments targeting elements of the DOM directly instead of fragile, performance-reducing, framework-dependent JSON. THIS is where you jump off the tech-churn hamsterwheel and future-proof yourself.

• MiniDataAPI: A lightweight layer for interacting with SQLite and other databases. Uses Python dictionaries for schema definition, promoting type safety without the complexity of traditional ORMs — effectively future-proofing your SQL. You lose fancy join capabilities but in exchange get the Python dict interface as your main persistent database API forever-forward, enabiling instant swapability between SQLite and PostgreSQL (for example).

• Ollama: Facilitates running LLMs locally, enabling in-app chat, workflow guidance, and future automation capabilities while ensuring privacy and avoiding API costs. Your local AI (Chip O'Theseus) learns & grows with you, hopping from hardware to hardware as you upgrade — like a genie in a hermitcrab shell. And if that weren't kooky enough — it knows how to make MCP-calls!!! That's right, your friendly localhost AI Chip O'Theseus is also an MCP client! Your linear workflows ain't so linear anymore when a single-step can be: "Go out and do whatever."

The Universal API Pattern: From Quarks to Code

At every scale of reality, we see the same pattern: "lumps of stuff" with APIs that enable interaction. Quarks combine into atoms, atoms into molecules, cells into organisms, individuals into societies. Each level requires the right granularity of interface — not so abstract that you lose control, not so granular that you drown in complexity.

This is the 80/20 rule of existence: Handle 80% of interactions gracefully with 20% of the API surface, then handle edge cases as needed. Pipulate applies this principle to code architecture.

🔍 SEO Workflows

• Keyword Research Pipeline: Input seed keywords → AI expansion → competition analysis → export spreadsheet
• Content Gap Analysis: Compare your site vs competitors → identify missing topics → prioritized content calendar
• Technical SEO Audits: Crawl site → check Core Web Vitals → generate action items → track fixes

📊 Data Processing Workflows

• CSV Data Cleaning: Upload messy data → standardize formats → remove duplicates → validate results
• API Data Collection: Connect to APIs → fetch data in batches → transform to consistent format → store locally
• Report Generation: Combine multiple data sources → apply business rules → create branded reports

🤖 AI-Assisted Workflows

• Content Creation Pipeline: Research topics → generate outlines → write drafts → optimize for SEO
• Data Analysis Helper: Upload spreadsheet → AI suggests insights → create visualizations → export findings

Key advantage: Each workflow is a guided, step-by-step process that non-technical users can run repeatedly, while developers can customize the Python code behind each step.

AI On Rails: Structured Workflows for Any AI

The Challenge with Agentic AI: Powerful but unpredictable—you never know what you're gonna get.

The Pipulate Approach: Structured workflows that can leverage any AI—local, cloud, or hybrid—while maintaining complete visibility and control.

Think of it as putting guardrails on AI assistance. Instead of asking an AI to "figure it out," domain experts create step-by-step workflows that guide AI through proven processes. The AI gets structure, you get predictable results.

Pipulate: Your AI Swiss Army Knife: Whether you prefer local privacy, cloud power, or hybrid approaches, Pipulate provides the framework. Use local models for sensitive work, cloud APIs for heavy lifting, or both in the same workflow—your choice, your control.

      🤖 AGENTIC MODE (Chaos)           🚂 AI ON RAILS (Pipulate)
      ═══════════════════════           ══════════════════════════

          💥 GOES OFF                      📊 LINEAR WORKFLOWS
          HALF-COCKED!                      BY DOMAIN EXPERTS
               │                                   │
               ▼                                   ▼
      ╔════════════════════╗            ┌─────────────────────┐
      ║  🌪️ WILLY NILLY 🎲 ║            │  Step 1: Analyze▸   │
      ║                    ║     VS     │  Step 2: Process▸   │
      ║   Unpredictable    ║            │  Step 3: Report▸    │
      ║      Results       ║            │  Step 4: Export▸    │
      ╚════════════════════╝            └─────────────────────┘
               │                                   │
               ▼                                   ▼
    ☁️ Trains Frontier Models        🏠 Keeps Domain Expertise Local

1. 🖥️ Runs locally like a desktop app using modern web technologies
2. 🐍 Simple linear workflow approach powered by HTMX for seamless interactivity
3. 📓 Transforms Jupyter Notebooks into production-ready, step-by-step workflows
4. 🤖 Integrated AI assistance using your own local models with complete privacy
5. 🔧 Reproducible environments with Nix that work identically across all platforms
6. 🎯 Perfect for SEO practitioners who want to turn technical expertise into guided, reusable workflows

--------------------------------------------------------------------------------

Levinix: A *very good* "No Problem" Universal Packager (NPvg)

```

Nix serves as the "Noah's Ark" creating easily re-hydrated environments that work identically across all platforms and forever into the future. The long promised Holy Grail of write-once run anywhere is today achieved with infrastructure-as-code (IaC) leveraging a fully featured generic normalized Linux called Nix.

Starting Workflows in Jupyter Notebooks

Pipulate's pipulate module can be imported in any Notebook, providing an ideal location to mock up new, fully operational workflows that are easy to port into the Pipulate Web App later. A simple:

import pipulate as pip

...at the top of a Notebook (following the conventions of import numpy as np) gives you all of Pipulate's state-management capabilities. This dramatically simplifies notebook logic, compels adherence to a linear input -\> process -\> output pattern, and makes porting to the web UI trivial.

The abstract template is:

```python import pipulate as pip

Workflow Patterns & Development

Pipeline Workflows

Designed for porting notebook-style processes, workflows are sequences of steps where the state is managed explicitly at each stage and stored persistently (typically as a JSON blob in the pipeline table). Resumable & Interrupt-Safe: Because each step's completion is recorded, workflows can be stopped and resumed. Explicit State Flow: Data typically passes from one step's output (done field) to the next via the transform function, simplifying debugging. Patterned on Unix pipes. Good Training Data: The structured input/output of each step creates valuable data for potentially fine-tuning models. Proprietary Friendly: Excellent for proprietary domain-experts and fields (competing academic, finances) who resist letting their data flow onto the Web for general AI training.

  ┌─────────┐        ┌─────────┐        ┌─────────┐   - Fully customizable steps
  │ Step 01 │─piped─►│ Step 02 │─piped─►│ Step 03 │   - Interruption-safe & resumable
  └─────────┘        └─────────┘        └─────────┘   - Easily ported from Notebooks
       │                  │                  │        - One DB record per workflow run
       ▼                  ▼                  ▼        - Everything stays on your machine
  State Saved        State Saved         Finalized?   - Magnitudes simpler than celery

LLM Integration (Ollama)

Integration with a local Ollama instance provides AI capabilities without external API calls: Privacy: Prompts and responses stay local. Cost-Effective: No per-token charges; run continuously using local resources. Streaming Support: Real-time interaction via WebSockets. Bounded Context: Manages conversation history effectively. App State Awareness: Grepping your server log reveals full application state. Tool Calling: Local LLM is an MCP client with a growing list of abilities - Workflow assistance - Browser automation - Debugging

                   ┌──────────────────┐
                   │   Local Ollama   │ - No API keys needed
                   │      Server      │ - Completely private processing
                   └────────┬─────────┘
                            │
                            │ Streaming via WebSocket
                            ▼
                   ┌──────────────────┐
                   │   Pipulate App   │ - Monitors WS for MCP tool-call commands
                   │(WebSocket Client)│ - Parses responses in real-time
                   └────────┬─────────┘
                            │
                            │ In-memory or DB backed
                            ▼
                   ┌──────────────────┐
                   │     Bounded      │ - Manages context window (~128k)
                   │   Chat History   │ - Enables RAG / tool integration
                   └──────────────────┘

UI Component Hierarchy: Complete DOM Structure with IDs & ARIA Labels

Critical for AI assistants: All UI components use semantic IDs and comprehensive ARIA labeling for accessibility and automation.

``` 🏠 home (Root Component) ├── 📦 create_outer_container() │ ├── 🧭 create_nav_group() [id='nav-group', role='navigation', aria-label='Main navigation'] │ │ ├── 🔍 nav_search_container [role='search', aria-label='Plugin search'] │ │ │ ├── Input [id='nav-plugin-search', role='searchbox', aria-label='Search plugins'] │ │ │ └── Div [id='sear

Desktop App Architecture: Electron vs Pipulate

        🖥️ ELECTRON PATTERN                 🌐 PIPULATE PATTERN
      ═══════════════════════             ═══════════════════════

    ┌─────────────────────────┐        ┌─────────────────────────┐
    │      ELECTRON APP       │        │     PIPULATE SETUP      │
    ├─────────────────────────┤        ├─────────────────────────┤
    │ ┌─────┐ ┌─────┐ ┌─────┐ │        │ ┌─────────────────────┐ │
    │ │.exe │ │.dmg │ │.deb │ │        │ │     install.sh      │ │
    │ └─────┘ └─────┘ └─────┘ │        │ │ (Works on ALL OSes) │ │
    │   Per-OS Installers     │        │ └─────────────────────┘ │
    └───────────┬─────────────┘        └───────────┬─────────────┘
                │                                  │
                ▼                                  ▼
    ┌─────────────────────────┐        ┌─────────────────────────┐  This is new.
    │   📱 Native Window      │        │ 🖥️ Terminal Console     │    ,       O
    │  ┌─────────────────┐    │        │ ┌─────────────────────┐ │    \\  .  O
    │  │  Web Browser    │    │        │ │ nix develop (./run) │ │    |\\/| o
    │  │  (Bundled)      │    │        │ │ Starting servers... │ │    / " '\
    │  │  ┌───────────┐  │    │        │ │ ✓ JupyterLab ready  │ │   . .   .
    │  │  │           │  │    │        │ │ ✓ Pipulate ready    │ │  /    ) |
    │  │  │   HTML    │  │    │        │ └─────────────────────┘ │ '  _.'  |
    │  │  │   CSS     │  │    │   +    └─────────────────────────┘ '-'/    \
    │  │  │   JS      │  │    │                    │
    │  │  │           │  │    │                    ▼
    │  │  └───────────┘  │    │        ┌─────────────────────────┐
    │  └─────────────────┘    │        │ 🌐 Regular Browser      │
    │          │              │        │ ┌─────────────────────┐ │
    │          ▼              │        │ │ localhost:5001      │ │
    │ ┌─────────────────┐     │        │ │ ┌─────────────────┐ │ │
    │ │   Node.js       │     │        │ │ │  Python/HTMX    │ │ │
    │ │   Runtime       │     │        │ │ │  Workflows      │ │ │
    │ └─────────────────┘     │        │ │ │  Local AI       │ │ │
    └─────────────────────────┘        │ │ └─────────────────┘ │ │
                                       │ └─────────────────────┘ │
✅ Feels like native app               └─────────────────────────┘
❌ Multiple installers needed
❌ Platform-specific builds             ✅ Universal installer
❌ Update distribution complexity       ✅ Auto-updates via git
                                        ✅ Same experience all OSes
                                        ✅ Complete reproducibility

Installation Strategy: Universal First, PyPI Alternative

We offer two installation paths that lead to the exact same robust, Nix-managed environment. Choose the path that best fits your experience level and preferences.

                            ┌────────────────────────────┐
                            │      New User on macOS     │
                            └─────────────┬──────────────┘
                                          │
                  ┌───────────────────────┴───────────────────────┐
                  │                                               │
                  ▼                                               ▼
  ┌──────────────────────────────────┐   ┌───────────────────────────────────────────┐
  │ PATH 1: Recommended for Everyone │   │ PATH 2: Alternative for Python Developers │
  └──────────────────────────────────┘   └───────────────────────────────────────────┘
                  │                                               │
  "I want the simplest, most               "I prefer managing my command-line
   direct way to get this running."        tools with standard Python utilities."
                  │                                               │
                  ▼                                               ▼
  1. `curl ... [nix]`                      1. `brew install pipx` (If needed)
  2. `curl ... [pipulate]`                 2. `pipx install pipulate`
                                           3. `pipulate install`
                  │                                               │
                  └───────────────┐               ┌───────────────┘
                                  │               │
                                  ▼               ▼
                            ┌────────────────────────────┐
                            │    Nix-Managed Pipulate    │
                            │        Environment         │
                            └────────────────────────────┘
                                         ||
                                    (Identical
                                      Result)

PATH 2: Alternative Installation via PyPI (For Python Developers)

If you are a developer comfortable with tools like Homebrew and pipx, you can use our PyPI package as a gateway to the same robust installation.

Step 1: Install pipx

pipx is a tool for safely installing Python command-line applications. If you don't have it, you can install it with Homebrew.

brew install pipx

Step 2: Install the Pipulate CLI

Use pipx to install the pipulate command-line tool. This will not cause conflicts with your system Python.

pipx install pipulate

Step 3: Run the Installer

Use the command you just installed to set up the full Pipulate application.

pipulate install

This will trigger the same universal installation process, resulting in the exact same robust, Nix-managed environment. To run it in the future, just type pipulate run.

These few commands: - ✅ Updates to the latest version automatically - ✅ Starts JupyterLab and the Pipulate server - ✅ Opens web interfaces in your browser - ✅ Provides a complete, reproducible development environment

That's it! You now have a local-first development environment with AI integration, installed via your preferred Python toolchain.

Durable vs. Ephemeral: Building on Bedrock

The tech industry suffers from "hamster wheel syndrome" — constantly breaking APIs that force migration cycles. React (20+ versions), Node (frequent breaking changes), Angular (complete rewrites). This isn't progress; it's planned obsolescence.

Pipulate chooses durable foundations: - Linux Kernel: Version 6 in 30 years - Python: Version 3 in 30 years - HTML: Version 5 and stable - HTTP: Version 3 and backward compatible

These are the "laws of physics" for software — stable APIs that enable compound growth rather than constant rebuilding.

🚨 Installation Troubleshooting

Common Issues & Solutions:

System Requirements: - macOS: 10.15+ (Intel/Apple Silicon) - Linux: Any modern distribution with curl - Windows: WSL2 with Ubuntu 20.04+ - RAM: 4GB minimum, 8GB recommended - Disk: 2GB for installation + data storage - Network: Internet connection for initial setup only

---