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

-- Paste this into the playground and hit Run
levels: ["error","warn","info"]
read_file "server.log"
    > classify levels
    > summarize
    > print

GitHub Action

Run Pipe directly in CI/CD — no installation needed:

- uses: MachuraHarry/pipe/.github/actions/pipe-action@master
  with:
    script: |
      print "Hello from CI/CD!"
      log: exec "git log --oneline -20"
      print (get log "output")

→ GitHub Action Documentation

VSCode Extension

Syntax highlighting and full IntelliSense for .pipe files, powered by a Language Server Protocol client (vscode/) and the pipe-lsp server (cmd/pipe-lsp):

• Completion, hover docs, signature help, go-to-definition, references, rename
• Diagnostics (parse errors, undefined/unused variables) and semantic highlighting
• Format document, auto-completion of brackets, auto-indent and code folding

make vsix     # builds the server and packages vscode/pipe-syntax-1.0.0.vsix

Or run the extension in development with F5 from the vscode/ folder. See VSCode Extension Documentation.

Module Ecosystem

Pipe has a curated module library — 23 reusable modules with version pinning:

pipe -search                 # Browse modules
pipe -search sql             # Filter by keyword
pipe -get sqlite             # Install latest
pipe -get [email protected]       # Install specific version

import "sqlite"                            -- database engine
import "pipe-http"                         -- HTTP client
import "mqtt"                              -- MQTT 5.0 client
import "discord.pipe" as d                 -- Discord webhooks + bot

idx: index_create h "knowledge"
index_add idx "Pipe is an AI-native language."
index_search idx "language" 3 > each print

→ Ecosystem Documentation | → Contribute a Module

Execution Modes

54 AI + MCP Builtins (41 AI + 13 MCP)

Understanding

summarize, translate, classify, extract, ask, generate, generate_json

Speed & Control

ai_stream, ai_batch, ai_parallel, ai_rate_limit, ai_chat, ai_chat_json

Search & Retrieval

web_search, wiki_search, embed, embed_batch, cosine_sim, dot_product, nearest

Agents & Tools

agent, agent_ask, agent_clear, ai_tool, ai_with_tools, tool_call, swarm_agent, ai_swarm, ai_swarm_trace, ai_swarm_stream, ai_vision

Config & Cost

ai_provider, ai_model, ai_host, ai_set_key, ai_timeout, ai_cache, ai_cost, ai_tokens, ai_cache_hits, ai_cache_misses

MCP — Model Context Protocol

mcp_server, mcp_serve_stdio, mcp_serve_sse, mcp_tools, mcp_resource, mcp_resource_template, mcp_prompt, mcp_resources, mcp_read_resource, mcp_prompts, mcp_prompt_get, mcp_use_stdio, mcp_use_sse

Self-Healing

try_ai, try_ai_log

Advanced Features

Self-Healing Code (try_ai)

ai_provider "deepseek"

result: try_ai
    "42" * 3           -- E002 Type Error -> AI wraps with to_num -> 126
catch e
    0                   -- only reached if AI fix fails

print result           -- 126

Parallel Pipeline (>>)

a: "Frage A"
    >> ask
b: "Frage B"
    >> ask
c: "Frage C"
    >> ask

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

Guard Clauses in Match

fn classify severity
    match severity
        | s if s > 9 -> "critical"
        | s if s > 5 -> "warning"
        | _ -> "info"

Concurrency: Channels

ch: chan 3
go { send ch "hello" }
go { send ch "world" }
print (recv ch) ++ " " ++ (recv ch)

Sandbox Profiles

sandbox_profile "safe" {fs: "read-only", network: false, exec: false, ai: true}
sandbox_profile "agent" {fs: "temp-only", network: true, exec: false, ai: true}

set_sandbox "safe"
read_file "/etc/config"     -- reading allowed
write_file "/etc/config"    -- E_SANDBOX blocked

Architecture

Source (.pipe) -> Lexer -> Parser -> AST -> [ Tree-Walker | Compiler + VM ]
                                              |
                                    Builtins (249 total: 41 AI + 13 MCP + 195 standard)
                                              |
                                MCP Server <-> MCP Clients (stdio + HTTP)

• 67 token types, 43 AST node types, 43 opcodes
• ~37,000 LoC Go, 752 tests, 101 example programs
• Zero dependencies — pure Go stdlib

Documentation

→ Full documentation (English) → Vollständige Dokumentation (Deutsch)

Project Structure

pipe/
├── cmd/
│   ├── pipe/main.go           # Entry point
│   └── pipe-lsp/              # Language Server Protocol server (IntelliSense)
├── pkg/
│   ├── ai/                    # AI provider integrations
│   ├── analysis/              # IntelliSense library (builtins, diagnostics, completion...)
│   ├── ast/                   # AST node definitions
│   ├── build/                 # Self-extracting binary builder
│   ├── cache/                 # Bytecode cache
│   ├── compiler/              # Compiler to bytecode
│   ├── eval/                  # Tree-walk interpreter
│   ├── formatter/             # Code formatter
│   ├── gen/                   # Code generation helpers
│   ├── lexer/                 # Lexer and tokens
│   ├── mcp/                   # MCP server + client (zero-dependency)
│   ├── object/                # Runtime objects
│   ├── parser/                # Parser
│   ├── stdlib/                # Standard library helpers
│   └── vm/                    # Bytecode VM
├── examples/                  # 87 example programs
├── test/integration/          # Integration tests
├── vscode/                    # VSCode extension (syntax highlighting + LSP client)
├── docs/                      # Documentation (DE + EN)
├── website/                   # Project website
├── modules/                   # Language modules (mqtt, discord, x, etc.)
├── Makefile
├── go.mod
└── LICENSE

Contributing

See CONTRIBUTING.md.

License

MIT — see LICENSE.