Langflow

Langflow is a Python server with a web editor. A flow is a directed graph of components (inputs, models, prompts, tools, vector stores, outputs), each a Python class that can be edited in place. The server runs the graph when a flow is called from the Playground, the v1 /run endpoint, the beta v2 Workflow API, webhooks, MCP or A2A.

Agent behaviour lives in the Agent component, which runs a tool-calling loop over whatever is connected to its Tools port. Multi-agent designs follow an agent-as-tool pattern: a secondary Agent in Tool Mode becomes one of the primary agent's tools, so the primary agent decides when to delegate. Flows can also call other flows or remote agents through MCP Tools and the A2A Agent component.

State is kept in a database, SQLite by default (tied to the virtual environment for pip installs) or external PostgreSQL via LANGFLOW_DATABASE_URL. Agents have chat memory on by default: messages are grouped by session_id and a configurable number of recent messages is fed back each turn; the Message History component adds filtering and external stores such as Mem0. HITL pauses write a checkpoint so a resumed run does not repeat finished steps.

Two documented mechanisms. A Human Input component placed in a flow pauses the run, creates a checkpoint and exposes one output branch per configured user action (for example Approve continues and Reject sends a draft back for revision). Alternatively, Requires approval can be switched on for individual tools in the Agent component's tools menu; the run pauses when the agent tries that tool until someone picks Approve or Reject in the Playground, and the decision is saved in chat history so a reloaded session shows it as resolved. In both cases the run resumes from the checkpoint without re-running completed steps.

uv pip install langflow

# Setup: uv venv lf && source lf/bin/activate && uv pip install langflow
#        uv run langflow run   # editor at http://127.0.0.1:7860
# In the editor: Chat Input -> Agent -> Chat Output, plus a second Agent in
# Tool Mode wired to the first Agent's Tools port. Copy the flow ID and an API key.
import os
import requests

url = "http://localhost:7860/api/v1/run/FLOW_ID"
payload = {
    "input_type": "chat",
    "output_type": "chat",
    "input_value": "Compare MCP and A2A in three bullet points.",
    "session_id": "demo-user-1",  # chat memory is grouped by session
}
headers = {"x-api-key": os.environ["LANGFLOW_API_KEY"]}
resp = requests.post(url, json=payload, headers=headers, timeout=120)
resp.raise_for_status()
print(resp.json())

• Needs Python 3.10 to 3.14 and uv; minimum 2 CPU cores and 2 GB RAM (4 GB recommended). Startup can take a few minutes.
• langflow includes provider extensions; langflow-base installs the same app without them, and both use the langflow command.
• With a pip install, the default SQLite database lives inside the virtual environment, so it is not shared between environments; back it up before upgrading, or set LANGFLOW_DATABASE_URL for PostgreSQL.
• A2A is off until LANGFLOW_A2A_ENABLED=true, and only flows saved as agent-type (Chat Input plus Chat Output) can be published; workflow-type flows return 404.
• The v2 Workflow API (including AG-UI streaming) is in Beta and may change.
• Keep the server patched: a 2026 advisory describes authenticated remote code execution through the MCP stdio transport, fixed in 1.9.0.

Yes, as both server and client. Each project can be served as an MCP server whose tools are its flows, and the MCP Tools component lets agents call external MCP servers.

Yes. Agent-type flows can be published as A2A agents and remote A2A agents can be called with the A2A Agent component, once LANGFLOW_A2A_ENABLED is set. The beta Workflow API can stream AG-UI events.

The code is MIT-licensed and free to self-host. No official pricing page was found; the website offers sign-up for a free cloud account.

A primary Agent component gets other agents as tools: switch the second Agent to Tool Mode and connect it to the primary agent's Tools port. The primary agent then decides when to call it.

Langflow and its components are written in Python and can be customized in Python. A separate TypeScript client package is documented for calling the Langflow API.