langflow-mcp-server

A Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to Langflow workflow automation platform.

Overview

langflow-mcp-server serves as a bridge between Langflow's workflow automation platform and AI models, enabling them to understand and work with Langflow flows effectively.

API Compatibility: This server is built on the Langflow API documentation and supports Langflow API version 1.7.2.

v3.0.0 - Consolidated Tools Mode

Version 3.0.0 introduces Consolidated Tools Mode - a new architecture that groups 93 individual tools into 15 action-based tools. This significantly reduces token usage and improves AI assistant context management.

Mode	Tools	Best For
Standard	93 tools	Full granular control
Consolidated	15 tools	Reduced token usage, better context

To enable consolidated mode:

LANGFLOW_CONSOLIDATED_TOOLS=true

Consolidated tools:

• flow - All flow operations (list, get, create, update, delete, download, upload, etc.)
• flow_execution - Run flows (run, run_advanced, run_session, webhook, process, predict)
• build - Build operations (start, status, cancel, vertices)
• folder - Folder management (list, get, create, update, delete, download, upload)
• project - Project management (list, get, create, update, delete, download, upload)
• variable - Variable operations (list, create, update, delete)
• knowledge_base - Knowledge base management (list, get, delete, bulk_delete, upload)
• file - File operations (list, upload, download, delete, get_image)
• monitor - Monitoring (builds, messages, sessions, transactions)
• user - User management (list, get, get_current, update, reset_password)
• auth - Authentication (login, auto_login, logout, refresh, api keys)
• store - Component store (list, get, tags, likes)
• registration - User registration (get, register)
• validation - Code/prompt validation (code, prompt)
• system - System info (health, version, logs, pictures, voices)

It provides structured access to:

• Flow Management - Create, read, update, delete, and execute Langflow flows
• Flow Execution - Run flows with inputs and trigger webhooks
• Build Operations - Compile, validate, and monitor flow builds
• Import/Export - Upload and download flows and projects
• Organization - Manage folders and projects
• Configuration - Manage global variables
• Knowledge Bases - Manage RAG document collections
• Component Discovery - List all available Langflow components

Quick Start

Prerequisites

• Node.js installed on your system
• A running Langflow instance
• Langflow API key

Installation

# Install from npm
npm install -g langflow-mcp-server

# OR clone the repository
git clone https://github.com/nobrainer-tech/langflow-mcp.git
cd langflow-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Configure environment
cp .env.example .env
# Edit .env with your Langflow instance URL and API key

Configuration

Edit .env file:

LANGFLOW_BASE_URL=http://localhost:7860
LANGFLOW_API_KEY=your-api-key-here
MCP_MODE=stdio
LOG_LEVEL=info

Claude Desktop Setup

Add to your Claude Desktop config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "langflow": {
      "command": "npx",
      "args": ["-y", "langflow-mcp-server"],
      "env": {
        "LANGFLOW_BASE_URL": "http://localhost:7860",
        "LANGFLOW_API_KEY": "your-api-key-here",
        "LANGFLOW_CONSOLIDATED_TOOLS": "true",
        "MCP_MODE": "stdio",
        "LOG_LEVEL": "error"
      }
    }
  }
}

Alternative (local installation):

{
  "mcpServers": {
    "langflow": {
      "command": "node",
      "args": ["/absolute/path/to/langflow-mcp/dist/mcp/index.js"],
      "env": {
        "LANGFLOW_BASE_URL": "http://localhost:7860",
        "LANGFLOW_API_KEY": "your-api-key-here",
        "MCP_MODE": "stdio",
        "LOG_LEVEL": "error"
      }
    }
  }
}

Restart Claude Desktop after updating configuration.

Docker Deployment

The MCP server can be run in a Docker container for easier deployment and isolation.

Quick Start with Docker

# Clone the repository
git clone https://github.com/nobrainer-tech/langflow-mcp.git
cd langflow-mcp

# Create .env file with your configuration
cp .env.example .env
# Edit .env with your Langflow instance URL and API key

# Build and run with docker-compose
docker-compose up -d

# View logs
docker-compose logs -f

# Stop the server
docker-compose down

Building Docker Image

# Build the image
docker build -t langflow-mcp-server:latest .

# Run in stdio mode (for Claude Desktop)
docker run -it --rm \
  -e LANGFLOW_BASE_URL=http://localhost:7860 \
  -e LANGFLOW_API_KEY=your-api-key \
  langflow-mcp-server:latest

# Run in HTTP mode (for remote access)
docker run -d \
  -p 3000:3000 \
  -e MCP_MODE=http \
  -e PORT=3000 \
  -e AUTH_TOKEN=your-secure-token \
  -e LANGFLOW_BASE_URL=http://langflow:7860 \
  -e LANGFLOW_API_KEY=your-api-key \
  langflow-mcp-server:latest

Docker Compose Configuration

The included docker-compose.yml supports both stdio and HTTP modes:

# STDIO mode (default)
environment:
  - MCP_MODE=stdio
  - LANGFLOW_BASE_URL=http://localhost:7860
  - LANGFLOW_API_KEY=your-key

# HTTP mode
environment:
  - MCP_MODE=http
  - PORT=3000
  - AUTH_TOKEN=your-secure-token

Deprecated Tools

⚠️ Important: This server includes 4 deprecated tools that match deprecated endpoints in Langflow API 1.6.4:

• build_vertices - Use build_flow instead
• get_vertex - Use build_flow or get_flow instead
• stream_vertex_build - Use get_build_status with streaming instead
• get_task_status - Use get_build_status instead

These tools are enabled by default but marked with ⚠️ warnings. To disable them, set:

ENABLE_DEPRECATED_TOOLS=false

Available MCP Tools

Once connected, Claude can use:

• Standard mode: 93 individual tools (97 with deprecated tools enabled)
• Consolidated mode: 15 action-based tools (recommended for reduced token usage)

Standard Mode Tools (93 tools)

Flow Management (6 tools)

• create_flow - Create a new Langflow flow
• list_flows - List all flows with pagination and filtering
• get_flow - Get details of a specific flow by ID
• update_flow - Update an existing flow
• delete_flow - Delete a single flow
• delete_flows - Delete multiple flows at once

Flow Execution (2 tools)

• run_flow - Execute a flow with input configuration (supports streaming)
• trigger_webhook - Trigger a flow via webhook endpoint

Import/Export (3 tools)

• upload_flow - Upload a flow from JSON data
• download_flows - Download multiple flows as JSON export
• get_basic_examples - Get pre-built example flows

Folder Management (5 tools)

• list_folders - List all folders with pagination
• create_folder - Create a new folder
• get_folder - Get folder details by ID
• update_folder - Update folder name, description, or parent
• delete_folder - Delete a folder

Project Management (7 tools)

• list_projects - List all projects with pagination
• create_project - Create a new project
• get_project - Get project details by ID
• update_project - Update project name or description
• delete_project - Delete a project
• upload_project - Upload a project from JSON data
• download_project - Download a project as JSON export

Variable Management (4 tools)

• list_variables - List all global variables
• create_variable - Create a new variable
• update_variable - Update variable properties
• delete_variable - Delete a variable

Build Operations (3 tools)

• build_flow - Build/compile a flow and return job_id for async execution
• get_build_status - Poll build status and events for a specific job
• cancel_build - Cancel a running build job

Knowledge Base Management (4 tools)

• list_knowledge_bases - List all available knowledge bases
• get_knowledge_base - Get detailed information about a specific knowledge base
• delete_knowledge_base - Delete a specific knowledge base
• bulk_delete_knowledge_bases - Delete multiple knowledge bases at once

Component Discovery (1 tool)

• list_components - List all available Langflow components

File Management (5 tools)

• upload_file - Upload a file to a specific flow
• download_file - Download a file from a flow
• list_files - List all files in a flow
• delete_file - Delete a file from a flow
• get_file_image - Get an image file from a flow

Monitoring & Analytics (9 tools)

• get_monitor_builds - Get build execution history for a flow
• get_monitor_messages - Query chat/message history with filtering
• get_monitor_message - Get details of a specific message
• get_monitor_sessions - List all chat session IDs
• get_monitor_session_messages - Get all messages for a session
• migrate_monitor_session - Migrate messages between sessions
• get_monitor_transactions - List transaction logs for a flow
• delete_monitor_builds - Delete build history for a flow
• delete_monitor_messages - Delete multiple messages by ID

Vertex Operations ⚠️ DEPRECATED (3 tools)

• build_vertices ⚠️ DEPRECATED - Get vertex build order for a flow (use build_flow instead)
• get_vertex ⚠️ DEPRECATED - Get details of a specific vertex/component (use build_flow or get_flow instead)
• stream_vertex_build ⚠️ DEPRECATED - Stream real-time build events for a vertex (use get_build_status with streaming instead)

User Management (5 tools)

• list_users - List all users (admin only)
• get_current_user - Get current authenticated user info
• get_user - Get details of a specific user
• update_user - Update user profile information
• reset_user_password - Reset password for a user (admin only)

API Key Management (3 tools)

• list_api_keys - List all API keys for the user
• create_api_key - Create a new API key
• delete_api_key - Delete an API key

Custom Components (2 tools)

• list_custom_components - List all custom components
• create_custom_component - Create a new custom component

Authentication (4 tools)

• login - Authenticate with username and password
• auto_login - Auto-login with stored credentials
• refresh_token - Refresh authentication token
• logout - Logout and invalidate session

Store & Marketplace (6 tools)

• check_store - Check if component store is enabled
• check_store_api_key - Validate a store API key
• list_store_components - Browse available components in the store
• get_store_component - Get details of a store component
• list_store_tags - List all component tags in the store
• get_user_likes - Get components liked by user

Validation Tools (2 tools)

• validate_code - Validate Python code for custom components
• validate_prompt - Validate prompt template syntax

Advanced Execution (3 tools)

• run_flow_advanced - Advanced flow execution with full control
• process_flow - Legacy process endpoint for flows
• predict_flow - Legacy predict endpoint for flows

Batch & Public Operations (3 tools)

• get_public_flow - Get a public flow without authentication
• batch_create_flows - Create multiple flows in one operation
• get_task_status ⚠️ DEPRECATED - Get status of an async task (use get_build_status instead)

Folder Operations (2 tools)

• download_folder - Download entire folder as archive
• upload_folder - Upload folder from archive

Starter & Templates (2 tools)

• list_starter_projects - List available starter templates
• upload_knowledge_base - Upload file to create/update knowledge base

Profile & Media (2 tools)

• list_profile_pictures - List available profile pictures
• get_profile_picture - Get a specific profile picture

Integration Tools (1 tool)

• list_elevenlabs_voices - List ElevenLabs text-to-speech voices

System & Health (3 tools)

• get_version - Get Langflow API version information
• health_check - Check Langflow instance health status
• get_logs - Retrieve system logs (supports streaming)

Example Usage

// Create a new flow
create_flow({
  name: "My Automation Flow",
  description: "A flow that processes data"
})

// List all flows
list_flows({
  page: 1,
  size: 50
})

// Get flow details
get_flow({
  flow_id: "flow-uuid-here"
})

// Update a flow
update_flow({
  flow_id: "flow-uuid-here",
  name: "Updated Flow Name"
})

// Execute a flow
run_flow({
  flow_id_or_name: "my-flow-name",
  input_request: {
    input_value: "Hello World",
    output_type: "chat",
    input_type: "chat"
  },
  stream: false
})

// Trigger via webhook
trigger_webhook({
  flow_id_or_name: "my-flow",
  input_request: {
    input_value: "Process this data"
  }
})

// Build a flow (compile/validate)
build_flow({
  flow_id: "flow-uuid-here",
  log_builds: true,
  event_delivery: "polling"
})

// Check build status
get_build_status({
  job_id: "job-uuid-from-build",
  event_delivery: "polling"
})

// List knowledge bases (RAG)
list_knowledge_bases()

// Get knowledge base details
get_knowledge_base({
  kb_name: "my-documents"
})

// Create a folder
create_folder({
  name: "My Flows",
  description: "Organized flows"
})

// Create a project
create_project({
  name: "My Project",
  description: "Project description"
})

// Manage variables
create_variable({
  name: "API_KEY",
  value: "secret-key",
  type: "string"
})

// Get basic examples
get_basic_examples()

// List all components
list_components()

Development

# Build
npm run build

# Run in development mode
npm run dev

# Run tests
npm test

# Type checking
npm run typecheck

Project Structure

langflow-mcp/
├── src/
│   ├── mcp/
│   │   ├── index.ts       # MCP server entry point
│   │   ├── server.ts      # MCP server implementation
│   │   └── tools.ts       # Tool definitions
│   ├── services/
│   │   └── langflow-client.ts  # Langflow API client
│   ├── types/
│   │   └── index.ts       # TypeScript types
│   └── utils/
│       └── logger.ts      # Logging utility
├── .env.example           # Example configuration
├── package.json
├── tsconfig.json
└── README.md

Attribution

This project is inspired by and follows the structure of n8n-mcp by Romuald Czlonkowski. Special thanks to the n8n-mcp project for the excellent MCP server architecture and implementation patterns.

License

MIT License - see LICENSE for details.

Contributing

Contributions are welcome! Please:

1. Fork the repository
2. Create a feature branch
3. Run tests (npm test)
4. Submit a pull request

Acknowledgments

• Langflow team for the workflow automation platform
• Anthropic for the Model Context Protocol
• czlonkowski/n8n-mcp for the inspiration and architecture

---

Built with ❤️ for the Langflow community