Langflow + Ollama: The Most-Starred Visual Agent Builder, Fully Local

Short answer: uv pip install langflow, uv run langflow run, then drop an Ollama component into a flow and set Base URL to http://127.0.0.1:11434. That is the whole local stack — Langflow's open-source version is MIT-licensed and free, sits at 152,859 GitHub stars (more than Flowise and Dify, as of August 5, 2026), and its official Ollama components make a 100%-local, zero-API-key agent a five-minute job on any machine with 4GB of RAM to spare.

Langflow is the drag-and-drop canvas: components for models, prompts, tools, and vector stores that you wire together into chatbots, RAG pipelines, and agents, then test in a built-in Playground. Ollama is the engine behind it. This guide self-hosts the free OSS version, connects a local Ollama server the official way, builds a real tool-calling agent flow, and is honest about where the combination creaks. Everything below was verified against the Langflow docs and repo in August 2026, on version 1.11.2.

---

Why Langflow, Why Now

Langflow is the most-starred visual AI builder you can self-host — 152,859 GitHub stars against Dify's 151,401 and Flowise's 55,170 (GitHub, August 5, 2026) — and the only one of the three under a plain MIT license.

We have covered this category for a while — our Flowise + Ollama guide and Dify self-hosted guide are two of the most-read builder pages on this site — and Langflow was the conspicuous gap. It should not have been, because on paper it is the strongest local-first pick of the trio:

• License: MIT, full stop. Dify uses its own custom license; Flowise is Apache 2.0 with commercial-license carve-outs for its enterprise directory (per each repo's LICENSE file). MIT means no restrictions worth reading twice for a homelab or an internal tool.
• Stack: pure Python (3.10-3.14 supported). If you can write a Python function, you can write a custom Langflow component. Flowise is Node.js; Dify is a multi-container platform.
• First-party Ollama support: the docs ship a dedicated Ollama bundle — a text-generation component and an embeddings component — not a community plugin.
• Alive and funded: version 1.11.2 shipped August 4, 2026, with commits landing the day we checked (GitHub). Langflow is developed under DataStax, and IBM's acquisition of DataStax closed May 28, 2025 — corporate backing with deep pockets, though see the limitations section for the flip side.

The star count deserves one honest note: stars measure attention, not quality. But a gap this large (Langflow has roughly 2.8x Flowise's stars) does reflect where the ecosystem's tutorials, templates, and bug reports are accumulating, and that gravity matters when you hit a weird error at 11pm.

---

What Is Actually Free

Everything in this guide is free: the self-hosted open-source version is MIT-licensed with no feature gates we could find, and Ollama removes the other usual cost — model API fees. Langflow the company also sells things, so here is the honest map, because "is Langflow free?" now has three answers:

The cloud tier exists to host flows for you, which is exactly what you are here to avoid. The one thing to internalize: "Same Langflow whether you're using OSS or Cloud" is Langflow's own positioning — the self-hosted version is not a demo of a paid product. Combined with Ollama, your total bill is electricity.

---

Install: pip/uv or Docker

Fastest path: uv pip install langflow then uv run langflow run — Langflow is at http://127.0.0.1:7860 in about two minutes. For anything long-lived, use Docker with a volume so your flows survive container restarts. All commands below are from the official docs (docs.langflow.org), August 2026.

Requirements (per the docs): Python 3.10-3.14, dual-core CPU and 2GB RAM minimum, multi-core and 4GB+ recommended. Note what is missing from that list: a GPU. Langflow is just the orchestrator — the hardware budget belongs to Ollama and whatever model you load behind it. If you are sizing a machine for the whole stack, our 8GB VRAM model picks cover the small-model sweet spot that agent flows actually need.

Option 1: uv (bare metal)

# install (docs recommend uv over plain pip)
uv pip install langflow

# start the server
uv run langflow run

Open http://127.0.0.1:7860. Upgrades later are uv pip install langflow -U, and you can pin a version with uv pip install langflow==1.4.22-style syntax if a release breaks something (see limitations — 1.x moves fast).

Option 2: Docker

docker run -p 7860:7860 \
  -v langflow-data:/app/langflow \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER_PASSWORD=change-me \
  langflowai/langflow:latest

Two things the quickstart tutorials tend to skip, both from the deployment docs:

1. The Docker image ships with LANGFLOW_AUTO_LOGIN=false — you must set LANGFLOW_SUPERUSER_PASSWORD and log in as langflow superuser. That default is good news (an unauthenticated flow builder that can execute code should not be one -p flag away from your LAN), but it surprises people migrating from older tutorials.
2. No volume, no flows. Mount /app/langflow (the LANGFLOW_CONFIG_DIR) or your work vanishes with the container. For production, the docs' docker_example compose file adds Postgres via LANGFLOW_DATABASE_URL instead of the default SQLite — worth it the day two people share the instance, not before.

Either way, you also need Ollama itself running — if it is not already on your machine, install it, ollama pull a model, and confirm http://127.0.0.1:11434 answers before continuing.

---

Connect Ollama

One component, one field: add the Ollama component to a flow, set Base URL to http://127.0.0.1:11434, click Refresh, and every model on your Ollama server appears in the Model Name dropdown. No API key, nothing to configure server-side.

The official Ollama bundle gives you two components:

• Ollama (text generation) — outputs either a Model Response (plain message) or a Language Model port, which is the one that matters: it lets any LLM-driven component, including the Agent, run on your local model.
• Ollama Embeddings — local embeddings for vector stores, which makes fully-local RAG possible (our local RAG agent build is the natural next step once your connection works).

Three gotchas that account for most "Langflow can't see Ollama" threads:

1. Docker networking. 127.0.0.1 inside the Langflow container is the container, not your machine. On macOS/Windows use http://host.docker.internal:11434; on Linux, add --add-host=host.docker.internal:host-gateway to the docker run, or run Ollama in the same compose network and use its service name.
2. Empty model dropdown. The list comes from the live server — if ollama list shows nothing, pull a model first, then hit the component's Refresh button.
3. Memory errors are Ollama's, not Langflow's. The docs are blunt: large models will throw model requires more system memory than is available. Drop to a smaller quant or a smaller model — the flow logic does not change at all, which is half the point of building visually.

Model choice matters more than component wiring. For plain chat flows, anything runs. For agents, pull from the tools section of the Ollama library — as of August 2026 that includes qwen3.5 (0.8B up to 122B), gemma4 (12B/26B/31B), and granite4.1 (3B/8B/30B), among others. Our tool-calling model rankings sort out which of these actually follow instructions rather than merely advertising the tag.

---

Build a Real Agent Flow

The minimum viable local agent is four components: Chat Input → Agent → Chat Output, with the Ollama component's Language Model output plugged into the Agent's Language Model port and at least one tool attached. Ten minutes, no code, and the Playground gives you a chat window to test it immediately.

Here is the build, step by step:

1. Start from the Simple Agent template (or a blank flow). Langflow's starter templates pre-wire Chat Input → Agent → Chat Output for you.
2. Swap the brain for Ollama. The Agent component defaults to cloud providers via its Language Model dropdown. Ignore that: add the Ollama component, set Base URL, pick a tool-capable model (qwen3.5's mid sizes are a good default), then connect its Language Model output to the Agent's Language Model port. This "bring your own model component" input exists precisely so you are not limited to the built-in provider list — it is the documented path, not a hack.
3. Attach tools. This is where Langflow quietly beats writing agent loops by hand: any Langflow component can become a tool by enabling Tool Mode on it — including other agents and MCP servers, per the Agent docs. A Calculator component in Tool Mode is the classic smoke test: local models are bad at arithmetic, so "what is 847 * 293?" makes tool use visible instantly. If you have MCP servers running already (our MCP explainer covers what they are), plugging one into the Agent's Tools port turns every server capability into an agent tool at once.
4. Test in the Playground. Run it, ask something tool-shaped, and watch the agent's reasoning steps in the response — you can see each tool call it decides to make.
5. Ship it. Every flow is automatically an API endpoint on your Langflow server; the canvas's API panel gives you the curl/Python snippet. That is the underrated part of the whole product: the drag-and-drop artifact is also the deployment.

What to expect honestly: with a 9B-27B tool-capable model, single-tool flows work reliably; chains of three-plus tool calls get flaky, and the failure is almost always the model, not Langflow. The same flow pointed at a 122B model just behaves better. That is a model-quality gradient, and no visual builder abstracts it away — run the strongest tool-capable model your VRAM allows.

---

Langflow vs Flowise vs Dify

Pick Langflow for Python-native visual agent building under a clean MIT license; pick Flowise if your team lives in Node.js; pick Dify when you want a full self-hosted LLMOps platform rather than a canvas. The three get lumped together, but they are not interchangeable:

Star counts from the GitHub API on August 5, 2026; license terms from each repository's license file.

The honest framing: Dify is a platform, Langflow and Flowise are canvases. Dify's install brings a web app, workers, and databases because it is solving team-scale problems — if that is you, our Dify guide covers it. Between the two canvases, Langflow's Python core, MIT license, and 2.8x star gravity make it our default recommendation in 2026, with Flowise the right answer for JavaScript shops (our Flowise guide if so). And if your real goal is automation that occasionally calls an LLM — rather than an LLM app — none of the three beat n8n with Ollama.

---

Honest Limitations

Langflow + Ollama is genuinely good, but it is not magic: visual flows hit a complexity ceiling, 1.x releases move fast enough to break tutorials, and your agent is only as smart as the local model driving it. The specifics:

• The complexity ceiling is real. Around 15-20 components, a canvas becomes harder to reason about than code. Langflow's escape hatches (custom Python components, the API) help, but if you know today that you are building deeply stateful multi-agent systems, a code-first framework like LangGraph run locally is the better foundation — the canvas is for the 80% of ideas that never need that.
• Release velocity cuts both ways. Three 1.11.x releases landed in the weeks before we published (v1.11.2 on August 4, 2026). Active maintenance is great; it also means screenshots in six-month-old tutorials — sometimes including component names — do not match what you see. Trust the docs' version selector over any tutorial, including, eventually, this one.
• Local agent quality is a model problem. Tool-calling reliability below ~9B parameters is rough, and no orchestrator fixes that. Budget your hardware around the model tier you need, not around Langflow's cheerful 2GB minimum.
• Do not expose port 7860 to the internet casually. A flow builder is remote code execution by design — that is what "custom Python component" means. The Docker image's auth-on-by-default stance is the right one; keep it, use strong superuser credentials, and keep the port on your LAN or behind a VPN.
• The IBM question. IBM's acquisition of DataStax (Langflow's parent) closed in May 2025, and so far the observable signals are fine: MIT license intact, public repo shipping weekly. But big-company ownership has repackaged open-source projects before. Nothing today suggests that here — commit activity says the opposite — treat it as a watch item, not a blocker, and remember MIT means the code as it exists today stays free forever regardless.
• SQLite by default. Fine for one person; move to the documented Postgres setup before a second user shows up.

None of these change the verdict. They change how far you push it before reaching for code.

---

Sources

• Langflow docs — installation, Docker deployment, Ollama bundle, and Agent component references (commands quoted verbatim)
• Langflow GitHub repository — star count, MIT license, and v1.11.2 release data via the GitHub API, August 5, 2026
• Flowise and Dify repositories — star counts and license files, August 5, 2026
• Ollama model library — tool-capable model list, August 2026
• Wikipedia / IBM announcements — DataStax acquisition timeline (announced February 25, 2025; closed May 28, 2025)

---

FAQ