Pipe (SPR) MCP Server

Pipe — The MCP-native runtime, production-ready

The first language with built-in MCP — server and client. 249 builtins, single ~8 MB binary. Zero dependencies.

Officially listed in the [official MCP Registry](https://registry.modelcontextprotocol.io/?q=MachuraHarry) (v1.1.1, active). One-click install from GitHub MCP Registry for Copilot & VS Code.

What's New in v1.3

Pipe v1.3.0 builds on the multi-agent and vision work from v1.2.0:

• Multi-agent swarms — ai_swarm / ai_swarm_trace / swarm_agent: named agents hand a conversation off to one another via a reserved tool call, with the full message history carried forward. ai_swarm_stream adds live progress observation (tool calls, handoffs, reasoning, round-check callbacks to intervene mid-run) and now runs independent tool calls within a round in parallel where safe.
• `ai_vision` — ask a question about an image (an http(s) URL, local file, or raw bytes) via an OpenAI-compatible vision model.
• OpenCode Zen AI provider — 6th provider, with free-tier models usable without any API key.
• Built-in self-updater — pipe --update / --update-check fetch, checksum-verify and swap in the latest GitHub release.
• `tool_call` — direct, LLM-free invocation of a registered tool.
• `file_lock` / `file_unlock` — real cross-process advisory file locking.
• `elif` keyword in if/else chains.
• `ai_tool`: `parallel_safe` flag — batches of Pipe-defined fn tools can now run in parallel too, not just builtins.
• `pipe -build` now supports real multi-file projects, preserving relative subdirectory paths.
• Hardened sandbox — audit rounds 7-11: closed filesystem-write gate gaps, the wiki_search egress gap, an exec_whitelist shell-injection gap, and a hard-link escape.
• 249 builtins — 41 AI + 13 MCP + 195 standard, up from 226 in v0.9.3
• 23 modules — MQTT, SQLite, pipe-http, pipe-web, pipe-orm, pipe-cli, and more

Quick Install

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.

Installed copies update themselves against the latest GitHub release: pipe --update (or pipe --update-check to only look, pipe --version to show what you are on). The updater verifies the release checksum and replaces the binary in place.

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):

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):

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

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):

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

MCP Client — Use external tools

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

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

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

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

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

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

Features

• MCP-native — 13 builtins for MCP Server + Client. Pure Go stdlib. Connect to any stdio MCP server
• Ship AI pipelines 10x faster — 41 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 on workload (recursion-heavy code up to ~55x)
• Module ecosystem — 23 curated modules, registry with version pinning (@1.0.0). pipe -get installs, import by name
• Built-in testing — test blocks with assert_eq, assert_error. Run with pipe -test. Zero setup
• GitHub Action — Run Pipe directly in CI/CD. No installation needed
• VSCode Extension — Syntax highlighting, IntelliSense, LSP-powered diagnostics and completions
• Self-extracting binary — Ship your pipeline as a standalone executable (pipe -build)

Quick Start

git clone https://github.com/MachuraHarry/pipe && cd pipe && make build

export DEEPSEEK_API_KEY="sk-..." ./bin/pipe -vm -q -c 'ai_provider "deepseek"; ask "What makes Pipe different?" > print'

Try it in your browser

No install needed — Pipe runs fully in your browser via WebAssembly:

Open the Pipe Playground

-- Paste this into the playground and hit Run

le