pipe

# <img src="website/logo.svg" width="32" height="32" align="left" style="margin-right:8px"> Pipe — The MCP-native runtime, production-ready

[![CI](https://github.com/MachuraHarry/pipe/actions/workflows/ci.yml/badge.svg)](https://github.com/MachuraHarry/pipe/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-purple.svg)](LICENSE)
[![Version](https://img.shields.io/badge/version-v1.0.0-blue.svg)](https://github.com/MachuraHarry/pipe/releases)
[![SPR](https://img.shields.io/badge/SPR-Semantic%20Pipeline%20Runtime-7c5cfc.svg)](#)
[![MCP](https://img.shields.io/badge/MCP-Server%20%2B%20Client-3ce096.svg)](#model-context-protocol)
[![GitHub MCP Registry](https://img.shields.io/badge/GitHub_MCP_Registry-Listed-4a90d9.svg)](https://github.com/mcp/MachuraHarry/pipe)
[![MCP Registry](https://img.shields.io/badge/MCP_Registry-Listed-4a90d9.svg)](https://registry.modelcontextprotocol.io/?q=MachuraHarry)

> **The first language with built-in MCP — server and client. 238 builtins, single ~8 MB binary. Zero dependencies.**
> **Officially listed in the [official MCP Registry](https://registry.modelcontextprotocol.io/?q=MachuraHarry)** (v1.0.0, active). One-click install from [GitHub MCP Registry](https://github.com/mcp/MachuraHarry/pipe) for Copilot & VS Code.

## What's New in v1.0

Pipe v1.0.0 is the **production-ready release**, consolidating the entire v0.9.x series:

- **Guard clauses** — `| pattern if cond -> body` in match expressions
- **Concurrency primitives** — channels (`send`/`recv`/`try_recv`), mutex (`lock`/`unlock`), counting semaphore (`acquire`/`release`)
- **Bytecode-VM improvements** — constant folding, alias import namespaces, bytecode cache
- **MQTT 5.0 module** — pure Pipe MQTT client with input validation, CONNACK properties, DISCONNECT handling
- **docs-pipe** — RAG module for documentation-native search with heading-aware chunking
- **Test framework** — setup/teardown hooks, `assert_near`/`assert_contains`, VM test blocks
- **Hardened sandbox** — audit rounds 1-6, deterministic env masking, central egress gate
- **238 builtins** — 36 AI + 13 MCP + 189 standard, up from 226 in v0.9.3
- **23 modules** — MQTT, SQLite, pipe-http, pipe-web, pipe-orm, pipe-cli, and more

## Quick Install

```sh
curl -fsSL https://pipe-lang.com/install.sh | bash   # Linux & macOS
```

Windows (PowerShell): `irm https://pipe-lang.com/install.ps1 | iex`

The installer downloads the latest release, verifies its SHA256 checksum and installs `pipe` into `~/.local/bin` (or `/usr/local/bin` when run as root). Pin a version with `PIPE_VERSION=v1.0.0`. See the [full install docs](docs/en/01-getting-started.md).

## Privacy & DSGVO

Pipe is **DSGVO-konform / GDPR-compliant by design**:

- **Zero telemetry & analytics** — the binary never phones home, nothing leaves your machine
- **Self-hosted single binary** — runs entirely on your infrastructure
- **No cloud** — no vendor server processes your data
- **Open source (MIT)** — fully auditable
- **Local AI** — with Ollama, not a single byte leaves your network; cloud providers are used only if you configure one

## The Problem

Running AI in production is harder than it should be:

- **Security** — LLMs with file access, network, and `exec` are a liability. You need fine-grained sandboxing at the language level, not afterthought middleware.
- **Performance** — Sequential API calls turn a 1-second pipeline into a 10-second bottleneck. Parallelism shouldn't require `asyncio.gather()` boilerplate.
- **Vendor Lock-in** — Switching from OpenAI to DeepSeek means rewriting your Python SDK code. Provider changes should be one line.
- **Tool Integration** — Connecting LLMs to external tools (GitHub, databases, filesystems) is a maze of SDKs and API wrappers. MCP should be a language primitive, not a library.

**Pipe fixes this at the language level.**

## What is Pipe?

Pipe is a **Semantic Pipeline Runtime (SPR)** — a pipeline-native language where `summarize`, `translate`, and `classify` sit on the same syntax level as `+`, `sort`, and `len`. Data flows top to bottom through composable transformations. One binary. Zero dependencies.

**Python + LangChain (~80 lines):**

```python
import openai
client = openai.OpenAI()
def summarize(text):
    r = client.chat.completions.create(model="gpt-4o", messages=[{"role":"user","content":text}])
    return r.choices[0].message.content
def translate(text, lang):
    r = client.chat.completions.create(model="gpt-4o",
        messages=[{"role":"system","content":f"Translate to {lang}"},{"role":"user","content":text}])
    return r.choices[0].message.content
text = open("news.txt").read()
print(translate(summarize(text), "de"))
```

**Pipe (5 lines):**

```pipe
read_file "news.txt"
    > summarize       -- LLM call
    > translate "de"  -- LLM call
    > print
```

## Model Context Protocol

Pipe has **built-in MCP** — both as a server and client. No SDKs, no npm packages, no Python. Pure Go stdlib.

### MCP Server — Expose your tools

```pipe
fn get_weather city
    match city
        | "Berlin" -> "22°C, sunny"
        | "London" -> "15°C, rainy"
        | _ -> city ++ ": no data"

ai_tool "get_weather" "Get weather for a city" {city: "City name"} get_weather
mcp_server "Weather Agent" "1.0.0"
mcp_serve_stdio
```

Configure in Claude Desktop (`claude_desktop_config.json`):

```json
{ "mcpServers": { "pipe": { "command": "/tmp/pipe", "args": ["agent.pipe"] } } }
```

### MCP Client — Use external tools

```pipe
ai_provider "deepseek"
ai_set_key "deepseek" (env "DEEPSEEK_API_KEY")

-- Connect to GitHub + Filesystem MCP servers
mcp_use_stdio "npx" "-y" "@modelcontextprotocol/server-github" {GITHUB_TOKEN: (env "GITHUB_TOKEN")}
mcp_use_stdio "npx" "-y" "@modelcontextprotocol/server-filesystem" "/tmp"

-- AI discovers and uses all tools automatically
result: ai_with_tools "You are a DevOps assistant." "Search pipe's open issues and list files in /tmp." 10
print result
```

**Any stdio MCP server** works immediately: Filesystem, GitHub, Git, Postgres, SQLite, Slack, Brave Search, Memory, Sequential Thinking — anything on npm/uvx.

## Use Cases

### Log Analysis → Incident Report

```pipe
is_critical: fn line
    contains line "critical"

read_file "/var/log/app/errors.log"
    > split "\n"
    > filter is_critical
    > summarize
    > translate "de"
    > save "incident_report.txt"
```

### RAG Pipeline

```pipe
ai_provider "deepseek"

docs: read_lines "knowledge_base.txt"
vectors: embed_batch docs

question: "How does the bytecode VM work?"
q_vec: embed question
top: nearest q_vec vectors 3

context: ""
for idx in top
    context: context ++ (at docs idx) ++ "\n---\n"

ask ("Context:\n" ++ context ++ "\nQuestion: " ++ question)
    > print
```

### AI Agent with Tool Calling

```pipe
fn get_weather city
    match city
        | "Berlin" -> "22°C, sunny"
        | "London" -> "15°C, rainy"
        | _ -> city ++ ": no data"

ai_tool "get_weather" "Get current weather for a city" {city: "Name of the city"} get_weather

ai_with_tools "You are a weather assistant." "What's the weather in Berlin and London?"
    > print
```

### Concurrency — 3 LLM Calls in 1.5s, Not 4s

```pipe
ai_provider "deepseek"

a: "Explain monads" >> ask
b: "What is CP/M?" >> ask
c: "Explain RFC 791" >> ask

print a ++ b ++ c   -- Future auto-resolution
```

### Discord CI/CD Notifications

```pipe
import "discord.pipe" as d
ai_provider "deepseek"

-- AI code review per commit, sent as Discord embed
review: ai_chat "Review this code change" diff 800

d.d_webhook_embed (env "DISCORD_WEBHOOK") {
    title: "CI: Push to master",
    color: 3447003,
    fields: [
        {name: "Changed Files", value: stat},
        {name: "AI Review", value: review}
    ]
}
```

## Comparison: Pipe vs Python + LangChain

|                          | Python + LangChain            | Pipe                           |
|--------------------------|-------------------------------|--------------------------------|
| **RAG pipeline**         | ~80 LOC                       | ~8 LOC                         |
| **Sandbox LLM access**   | Custom middleware              | One `sandbox_profile` block    |
| **Switch AI provider**   | Rewrite SDK calls              | `ai_provider "deepseek"`       |
| **Deploy to server**     | Docker + venv + pip            | `scp pipe binary`              |
| **Parallel LLM calls**   | `asyncio.gather()` boilerplate | `>>` operator, `ai_batch`      |
| **MCP Server + Client**  | Library-dependent              | 13 builtins, zero deps, 100+ servers |
| **Binary size**          | ~500 MB (with deps)            | ~8 MB                          |

## Features

- **MCP-native** — 13 builtins for MCP Server + Client. Pure Go stdlib. Connect to any stdio MCP server
- **Ship AI pipelines 10x faster** — 36 AI + 13 MCP builtins: no imports, no SDKs, no API wrappers
- **Lock down AI agents in one line** — Declarative sandbox profiles: restrict `exec`, `write_file`, `http_get` with a single block
- **Deploy in seconds** — One statically-linked ~8 MB binary. No venv, no pip, no Docker. Linux, macOS, Windows, Raspberry Pi, or your browser via WebAssembly
- **3 LLM calls in 1.5s, not 4s** — `>>` starts any pipeline stage in the background. Futures auto-resolve. `ai_batch` handles hundreds of texts concurrently with built-in rate limiting
- **No vendor lock-in** — OpenAI, Anthropic (Claude), DeepSeek, Ollama. Switch with one line. Same code works everywhere
- **Concurrency primitives** — channels (`send`/`recv`), mutex (`lock`/`unlock`), counting semaphore (`acquire`/`release`)
- **Pipeline-native syntax** — `>` sequential, `>>` parallel. Data flows top to bottom — readable, composable, debuggable
- **Social platforms built in** — Discord webhooks and Telegram bots as Pipe modules. AI code reviews, notifications, chat — zero API costs for sending
- **Bytecode VM** — Compile to bytecode, run on a stack VM with automatic caching. Measured 0.6x-55x vs tree-walker depending o