get_all_pipeline_statusesLABSCO SUMMARY
One wrapper class, four ways to call it.
The economy here is that the integration surfaces are generated rather than written. A single PipelineWrapper with a run method yields a validated REST endpoint, an OpenAI-compatible streaming chat backend, and an MCP tool — so the same Haystack agent serves a web app, Open WebUI, and Cursor without three adapters. The core tools go one step further and let the client deploy and undeploy pipelines mid-conversation.
What it is
A server that turns Haystack pipelines and agents into deployed services. You write a wrapper class with a setup method and a run method; Hayhooks generates the HTTP API, the OpenAI-compatible chat completions endpoint, and — running as an MCP server — an MCP tool per deployed pipeline.
What you get
- Each deployed pipeline or agent exposed as an MCP tool, so anything you built in Haystack becomes callable from Cursor or Claude Desktop
- Core tools for controlling Hayhooks itself from the client — read the status of everything deployed, deploy something new, or take it down —
get_all_pipeline_statuses,deploy_pipeline,undeploy_pipeline - A POST endpoint per pipeline with its input arguments auto-validated by a generated Pydantic model
- An OpenAI-compatible
/chat/completionsendpoint with streaming, which is what makes Open WebUI integration work - A2A support (
pip install "hayhooks[a2a]") with auto-generated agent cards, so other agents can discover a pipeline and delegate to it - An embedded Chainlit chat UI (
pip install "hayhooks[chainlit]", thenhayhooks run --with-chainlit) with streaming, pipeline selection and custom widgets, needing no configuration - OpenTelemetry tracing (
pip install "hayhooks[tracing]") covering deploy, run and undeploy across both REST and MCP, with request-level spans on the MCP transport endpoints and domain spans forlist_toolsandcall_tool, plus a/dashboardUI - Built-in file upload handling for pipelines that ingest documents
- Both YAML-based and wrapper-based deployment, plus a CLI for pipeline management
Requirements
Python 3.10+, and pip install hayhooks[mcp] — the MCP server comes with that extra. hayhooks run starts the REST server on port 1416; the MCP server is a separate command, hayhooks mcp run, listening on HAYHOOKS_MCP_HOST and HAYHOOKS_MCP_PORT — localhost:1417 by default — and serving Streamable HTTP at /mcp with SSE also supported. Clients that only speak stdio can bridge through supergateway. Deploy a pipeline with hayhooks pipeline deploy-files, passing -n and a name followed by the wrapper directory. The A2A, Chainlit and tracing features each come from their own extra. Whatever your pipeline itself needs — an OpenAI key for a chat generator, for instance — is on you.
Setup effort
Follow the published steps — pip install hayhooks[mcp]
USE CASES
01
Making a Haystack pipeline callable from your IDE
Deploy it, run the MCP server, and it appears as a tool in Cursor or Claude Desktop alongside your other servers.
02
Managing deployments without leaving the conversation
Check what is running, deploy a new pipeline, and take down one you no longer need, all as tool calls.
03
Putting a chat UI in front of an agent
Install the Chainlit extra and start with the flag — streaming and pipeline selection come with it, with no frontend to build.
04
Serving a RAG pipeline to Open WebUI
Use the OpenAI-compatible chat completions endpoint with streaming, and the built-in file upload handling for document ingestion.
05
Seeing where time goes across REST and MCP
Install the tracing extra and read the request-level and domain spans, including list_tools and call_tool, in the dashboard.
4 tools
Listed in project docs. Your client may show a different list.
get_pipeline_statusdeploy_pipelineundeploy_pipelineBEFORE YOU INSTALL
What to know first
Tools you get
4 tools named in the project's documentation.
Requires
pip on PATH
Where it runs
Both documented clients run the server on your machine.
INSTALLATION
Connect your client
Server setup
TERMINAL
pip install hayhooks[mcp]Start the MCP server. It listens on http://localhost:1417/mcp, the address the client cards below point at, and stays running while you use it: hayhooks mcp run
Deploy a pipeline so it appears as a tool — from the terminal, pointing at the folder that holds its wrapper (or ask the client to call deploy_pipeline): hayhooks pipeline deploy-files -n my_pipeline <YOUR_PATH_TO_PIPELINE>
MCP Clients
Cursor — HTTP
CURSOR — HTTP · JSON
{
"mcpServers": {
"hayhooks": {
"url": "http://localhost:1417/mcp"
}
}
}Claude Desktop — free tier
CLAUDE DESKTOP — FREE TIER · JSON
{
"mcpServers": {
"hayhooks": {
"command": "npx",
"args": [
"-y",
"supergateway",
"--streamableHttp",
"http://localhost:1417/mcp"
]
}
}
}
