Langflow is an open-source visual builder where you assemble an AI agent by dragging blocks and connecting them with lines, with barely any code. Each block is a model, a tool, a database or a piece of logic, and the resulting canvas can be run, debugged and published as an API or as an MCP server. In this guide you will see what Langflow is, how to deploy it with Docker on your own machine, how to build your first agent flow and how it compares with its direct rival, Flowise. The same explanation is available in Spanish.

Key takeaways

  • Langflow is an open-source tool (MIT licence) for building AI agents and flows visually; it has over 151,900 stars on GitHub and its stable version is 1.10.2, released on 7 July 2026.
  • It is self-hostable: a single Docker container brings up the web canvas on port 7860, so your data and your keys never leave your network.
  • Flows are assembled by dragging blocks: models, prompts, tools, document loaders and vector databases connect like pieces of a diagram.
  • Any flow is published as an API (POST /api/v1/run/$FLOW_ID) or as an MCP server, so another application or agent can call it as just another tool.
  • It is written in Python (compatible with versions 3.10 to 3.14) and has belonged to IBM since the DataStax acquisition in 2025, while remaining free software.

What is Langflow?

Langflow is a visual environment for designing applications based on language models. Its repository defines it as "a powerful tool for building and deploying AI-powered agents and workflows". Instead of coding the orchestration by hand, you drag blocks onto a canvas and wire them together: the output of one block feeds the input of the next. The result is a graph that shows, at a glance, the entire path of a request.

The project started in February 2023 as a visual layer over LangChain and has grown into one of the most popular AI repositories, with more than 151,900 stars on GitHub. In 2025 it was acquired by DataStax, which in turn passed to IBM, but the core stays under the MIT licence and you can self-host the whole thing at no cost.

Its natural audience is two profiles. On one hand, whoever prototypes fast and prefers to see the logic rather than read it: analysts, product designers or developers who want to validate an idea in an afternoon. On the other, the team that already works in Python and wants to speed up the design phase without giving up the option of exporting the flow to code when it is time to take it to production.

Deploying it with Docker

Langflow’s big advantage over a cloud service is that it runs entirely on your own machine, so neither your documents nor your API keys leave your network. The fastest way to start it is a single container:

# Brings up the web canvas on http://localhost:7860
docker run -p 7860:7860 -e LANGFLOW_AUTO_LOGIN=true \
    langflowai/langflow:1.10.2

For a slightly more serious deployment, the repository includes a ready-to-use docker compose that separates the application from its Postgres database, where flows and history are stored:

git clone https://github.com/langflow-ai/langflow.git
cd langflow/docker_example

    # Starts Langflow + Postgres in the background
docker compose up -d

With the container up, open http://localhost:7860 in the browser and the canvas is right there. Before exposing it beyond your machine, turn off LANGFLOW_AUTO_LOGIN and set LANGFLOW_SUPERUSER and LANGFLOW_SUPERUSER_PASSWORD to protect the interface with a username and password. If you would rather skip Docker, you can install it as a Python package with uv pip install langflow and start it with uv run langflow run, as long as you have a Python version between 3.10 and 3.14.

Building an agent flow by dragging blocks

With the canvas open, the fastest way to understand Langflow is to start from one of its templates. The "Simple Agent" template already ships the essential blocks wired together and ready for you to change just a few values. A typical agent flow chains four pieces:

  • Chat Input: collects the user’s message and is the graph’s entry point.
  • Agent: the central block. It holds the model (for example an OpenAI GPT or a model served with Ollama on your own machine), the system instructions and the list of tools it can use.
  • Tools: blocks the agent calls when it needs them, such as a web search, a calculator or a query to a vector database to answer from your documents.
  • Chat Output: returns the final answer to the user.

You drag each block from the sidebar, pull from one port to another to connect them and fill in the parameters in a panel: the model’s API key, the temperature or the prompt text. As soon as you hit "Playground", Langflow runs the graph and you can chat with the agent right there, watching which tools it calls on each turn. That visual loop of assemble, test and tweak is what makes a working prototype come out in minutes, not hours. If the flow later grows complex, you can always migrate the logic to code with a framework like LangGraph.

Exposing it as an API

A pretty flow on the canvas is useless if you cannot call it from your application. Here is Langflow’s second big win: every flow is automatically an HTTP service. In the editor’s "Share" or "API access" button you get ready-made snippets for Python, JavaScript and curl. The basic call is a POST request to the flow’s identifier, authenticated with an API key:

curl -X POST \
    "http://localhost:7860/api/v1/run/$FLOW_ID" \
    -H "x-api-key: $LANGFLOW_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"input_value": "Hi, agent", "output_type": "chat", "input_type": "chat"}'

The body’s tweaks field lets you override any block’s parameters at run time (for example, switching the model or the temperature without editing the flow), which turns the same graph into a reusable template. On top of that, each project exposes an MCP server that publishes its flows as tools; so a client that speaks the Model Context Protocol can discover your flow and use it without knowing its internals. If you want to dig into that protocol, we have a guide to install an MCP server step by step.

Langflow versus Flowise

Langflow is not alone: its most cited alternative is Flowise, another open-source visual agent builder that sits around 54,700 stars on GitHub. Both share the same idea (a canvas of blocks published as an API), so the choice comes down to one decisive technical detail: the language.

  • Langflow is written in Python. It fits naturally if your team already works with Python’s data and machine-learning ecosystem, and if one day you want to export the flow to code, you land on LangChain.
  • Flowise is written in TypeScript on Node.js. It is the logical option for JavaScript teams that deploy on Node and prefer to integrate it into a web stack without leaving their language.

In visual capabilities they are very close. The rule of thumb is simple: pick the one that speaks your team’s language, because it is the one you will be able to extend with custom blocks and debug when something breaks. For prototyping and validating ideas, either one saves you days of scaffolding compared with writing the orchestration from scratch.

Frequently asked questions

Is Langflow free and open source?

Yes. All of Langflow’s core is free software under the MIT licence and you can self-host it at no cost, with no limit on flows or users. The company behind it (now IBM, after buying DataStax) also offers a paid managed cloud version for those who do not want to maintain the infrastructure, but you do not need it: the version you deploy with Docker is the same complete tool.

Do I need to know how to program to use Langflow?

To build and test a flow, no. Assembly is visual and the templates cover the common cases, so a non-technical profile can have an agent working in an afternoon. That said, to take it to production solidly you do want to understand concepts like API keys, environment variables and deployment security. Langflow lowers the barrier to entry a lot, but it does not remove the engineering part entirely.

Can I move from Langflow to code when the project grows?

Yes, and it is one of its best assets. Because Langflow builds on the LangChain ecosystem, the logic you design on the canvas has a direct equivalent in Python code. Many teams use it as a whiteboard: they prototype the idea visually, validate it with real users and, once the flow stabilises, rewrite the critical part in a code framework like LangGraph to gain more control over state and errors.

Conclusion

Langflow fills the gap between the idea and the working prototype: instead of writing an agent’s orchestration from scratch, you draw it, test it on the same canvas and publish it as an API or an MCP server in a matter of minutes. With a single docker run you get, on your own machine, an open-source tool under the MIT licence, with over 151,900 community stars behind it and the door open to exporting your flow to Python code when the project calls for it. The next step is to bring up the container, open the "Simple Agent" template and drag your first block.

Sources: [1] Official Langflow documentation[1], [2] Langflow on GitHub[2], [3] Langflow project site[3], [4] langflow package on PyPI[4].

Visitas: 0

Sources

  1. Official Langflow documentation
  2. Langflow on GitHub
  3. Langflow project site
  4. langflow package on PyPI

Route: Agent Ecosystem: MCP, Gateways and Platforms