Langflow MCP Server 1.6.4: 90 Workflow Tools

Overview

Langflow MCP Server 1.6.4 is a lightweight Model Context Protocol (MCP) server designed to automate and orchestrate Langflow workflows. It exposes a full HTTP API and a set of workflow “tools” that let you programmatically manage flows, trigger runs and jobs, produce builds, and integrate knowledge bases (KBs). The server packages orchestration primitives useful for building reproducible ML/AI pipelines, CI/CD for flows, and runtime management for production or batch workloads.

The server is useful when you need to automate Langflow tasks from other services (CI systems, schedulers, or webhooks), embed Langflow orchestration into higher-level apps, or run flows under controlled runtimes (Docker, local runtime, or remote executors). Version 1.6.4 contains a curated set of 90 workflow tools covering flow lifecycle, job scheduling, build pipelines, KB ingestion, storage access, and integration helpers.

Features

• 90 workflow tools covering flow management, jobs, builds, KBs, storage, and runtime helpers
• Full REST API for programmatic control and automation
• Docker-ready image and Docker Compose examples for reproducible deployment
• Knowledge base upload/management for grounded retrieval workflows
• Job scheduling and asynchronous run management
• Build artifacts and export/import for flows and runtime images
• Lightweight configuration via environment variables

Installation / Configuration

Quick start (clone and run locally):

git clone https://github.com/nobrainer-tech/langflow-mcp.git
cd langflow-mcp
pip install -r requirements.txt
python -m langflow_mcp.server --port 8080

Run with environment variables:

export MCP_HOST=0.0.0.0
export MCP_PORT=8080
export MCP_SECRET=my-secret-token
python -m langflow_mcp.server

Run with Docker:

docker run -d \
  --name langflow-mcp \
  -p 8080:8080 \
  -e MCP_SECRET=my-secret-token \
  nobrainertech/langflow-mcp:1.6.4

Docker Compose example:

version: "3.8"
services:
  langflow-mcp:
    image: nobrainertech/langflow-mcp:1.6.4
    ports:
      - "8080:8080"
    environment:
      - MCP_SECRET=${MCP_SECRET}
      - MCP_STORAGE=/data
    volumes:
      - ./data:/data

Common environment variables

Available Tools / Resources

Langflow MCP Server exposes workflow tools grouped by capability. Example categories:

• Flow management: create, read, update, delete, export, import, validate
• Run and jobs: execute flow, schedule job, poll job status, cancel run
• Builds: create build artifact, list builds, publish images
• Knowledge bases (KB): upload KB, attach KB to flow, list KBs, remove KB
• Storage & artifacts: upload/download artifacts, manage storage buckets
• Integrations: webhooks, external runtime connectors, Docker helpers
• Monitoring: logs, run metrics, traces

These tools are accessible through the REST API and can be orchestrated together to form CI pipelines, scheduled processing, or event-driven automations.

API Examples

Start a flow run (example):

curl -X POST "http://localhost:8080/api/v1/flows/run" \
  -H "Authorization: Bearer ${MCP_SECRET}" \
  -H "Content-Type: application/json" \
  -d '{
    "flow_id": "example-flow",
    "inputs": {"text": "Summarize this document"},
    "runtime": "default"
  }'

Check job status:

curl -X GET "http://localhost:8080/api/v1/jobs/{job_id}" \
  -H "Authorization: Bearer ${MCP_SECRET}"

Upload a knowledge base:

curl -X POST "http://localhost:8080/api/v1/kb/upload" \
  -H "Authorization: Bearer ${MCP_SECRET}" \
  -F "file=@./kb/faq.json" \
  -F "name=product-faq"

Python example using requests:

import requests, os
BASE = "http://localhost:8080/api/v1"
headers = {"Authorization": f"Bearer {os.environ['MCP_SECRET']}"}
resp = requests.post(f"{BASE}/flows/run", json={
    "flow_id": "example-flow",
    "inputs": {"text": "Hello"},
})
print(resp.json())

Use Cases

• CI for Langflow: Automate flow validation and build artifacts on push. Use the builds tools to generate reproducible images and store artifacts in MCP storage.
• Scheduled batch processing: Schedule jobs to run nightly data transformation flows and collect run metrics for audit.
• Knowledge-enabled bots: Upload and manage KBs via the KB tools, attach KBs to flows that perform retrieval-augmented generation (RAG), and keep KBs synchronized from a content pipeline.
• Webhook-driven automation: Trigger flows from external services (webhooks), pass event payloads into flows, and have MCP manage the run lifecycle and artifact archiving.
• Docker-based runtimes: Use Docker helpers to produce containerized runtime images for specific flows so you can run flows in isolated environments or deploy to container platforms.

Further Resources

• Source & issues: https://github.com/nobrainer-tech/langflow-mcp
• API docs: Browse the /docs or /openapi endpoint on a running instance for full endpoint details
• Community: Open issues and pull requests on GitHub for feature requests,