Pipe Docs (SPR) MCP Server
Docs + source RAG for Pipe language: semantic search, cited answers, code symbol lookup.
Open source Open in the app JSON README (API)
About
Docs + source RAG for Pipe language: semantic search, cited answers, code symbol lookup.
Details
- Kind
- MCP servers
- Topic
- AI, RAG & memory
- Publisher
- machuraharry
- Origin
- official
- Category
- ferramentas
- Transport
- local
- Version
- 1.1.0
- Stars
- 2
- Last push
- 2026-09-03T06:57:03Z
- Repository state
- ativo
- Language
- Go
- License
- MIT
- Added
- 2026-08-29 03:02:05
- Updated
- 2026-08-29 03:02:05
- Origin id
io.github.MachuraHarry/pipe-docs
README
# <img src="website/logo.svg" width="32" height="32" align="left" style="margin-right:8px"> Pipe — The MCP-native runtime, production-ready
[](https://github.com/MachuraHarry/pipe/actions/workflows/ci.yml)
[](LICENSE)
[](https://github.com/MachuraHarry/pipe/releases)
[](#)
[](#model-context-protocol)
[](https://github.com/mcp/MachuraHarry/pipe)
[](https://registry.modelcontextprotocol.io/?q=MachuraHarry)
> **The first language with built-in MCP — server and client. 246 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](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
- **246 builtins** — 36 AI + 13 MCP + 192 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).
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):**
```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 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
```bash
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:
<p align="center">
<a href="https://pipe-lang.com/playground.html">
<img src="website/logo.svg" width="64" height="64" alt="Pipe"><br>
<b>Open the Pipe Playground</b>
</a>
</p>
```pipe
-- 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:
```yaml
- 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](docs/en/20-github-action.md)
## 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
```sh
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](docs/en/15-vscode-extension.md).
## Module Ecosystem
Pipe has a [curated module library](https://github.com/MachuraHarry/pipe-modules) — **23 reusable modules** with version pinning:
| Infrastructure | Data & CLI | AI & Agents | DevTools | Social |
|---|---|---|---|---|
| `pipe-http` | `sqlite` | `rag-pipe` | `pipe-test` | `telegram-bot` |
| `pipe-cli` | `jpipe` | `log-analyzer` | `pipe-validate` | `mqtt` |
| `pipe-orm` | `pipe-tpl` | `sentiment` | | |
| `pipe-web` | `pipe-date` | `code-review` | | |
| | | `translate-batch` | | |
| | | `changelog-gen` | | |
| | | `email-classifier` | | |
| | | `incident-report` | | |
| | | `parallel-runner` | | |
| | | `date-formatter` | | |
| | | `docs-pipe` | | |
```bash
pipe -search # Browse modules
pipe -search sql # Filter by keyword
pipe -get sqlite # Install latest
pipe -get sqlite@0.8.0 # Install specific version
```
```pipe
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](docs/en/21-ecosystem.md) | [→ Contribute a Module](https://github.com/MachuraHarry/pipe-modules/blob/master/CONTRIBUTING.md)
## Execution Modes
| Mode | Command | Speed |
|------|---------|-------|
| Tree-Walker | `./bin/pipe script.pipe` | Baseline |
| Bytecode VM | `./bin/pipe -vm -q script.pipe` | 0.6x-55x (recursion-heavy up to ~55x) |
## 49 AI + MCP Builtins (36 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`
### 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`)
```pipe
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 (`>>`)
```pipe
a: "Frage A"
>> ask
b: "Frage B"
>> ask
c: "Frage C"
>> ask
print a ++ b ++ c -- Future auto-resolution
```
### Guard Clauses in Match
```pipe
fn classify severity
match severity
| s if s > 9 -> "critical"
| s if s > 5 -> "warning"
| _ -> "info"
```
### Concurrency: Channels
```pipe
ch: chan 3
go { send ch "hello" }
go { send ch "world" }
print (recv ch) ++ " " ++ (recv ch)
```
### Sandbox Profiles
```pipe
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 (246 total: 36 AI + 13 MCP + 192 standard)
|
MCP Server <-> MCP Clients (stdio + HTTP)
```
- 67 token types, 36 AST node types, 43 opcodes
- ~37,000 LoC Go, 643 tests, 87 example programs
- Zero dependencies — pure Go stdlib
## Documentation
[→ Full documentation (English)](/docs/en/index.md)
[→ Vollständige Dokumentation (Deutsch)](/docs/de/index.md)
## 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](CONTRIBUTING.md).
## License
MIT — see [LICENSE](LICENSE).