Langflow

2.1 Run your first Langflow agent

Langflow provides a visual canvas where blocks map directly to editable Python code and includes ready‑made templates such as Simple Agent.

Launch Langflow, load the Simple Agent template and watch it solve a calculation

Open Langflow → New Flow → pick the Simple Agent template → paste an OpenAI API key → click Playground and type the line above.

1. Install Langflow using the Desktop app on a machine with Python 3.10–3.14 and at least 2 GB RAM
2. Open Langflow, click New Flow, choose the Simple Agent template and paste your OpenAI API key into the model block’s settings
3. Click Playground, type “I want to add 4 and 4.” and press Send

• You'll see The agent reasons aloud, selects the Calculator tool and returns 8
• Takeaway A ready‑made template becomes an interactive tool‑using agent in minutes
• Check The Simple Agent answered “4 + 4” by calling a Calculator instead of doing the arithmetic itself. Why is that the point of the lesson?
• Cost Langflow is free and open-source (MIT) — you self-host it at no cost. You pay only your own infrastructure plus the LLM API key you bring (here, a few cents of OpenAI usage).

2.2 Inspect a flow on the canvas and view its code

A flow consists of blocks and wires; each block represents a single operation whose underlying Python can be opened for editing.

Do this first Run your first Langflow agent

Create a simple flow, connect its blocks, and open any block to see the underlying Python

Build it on the same Simple Agent flow or a blank one — Langflow is a visual front end over Python and LangChain, so wiring blocks is the same as composing those steps in code.

1. Drag a component from the left‑hand list onto the canvas
2. Connect two blocks by dragging a wire from an output port to an input port
3. Click a block’s settings icon to open its editable Python view

• You'll see A small flow you assembled — input → model → output — that responds when you open the Playground
• Takeaway Langflow lets you design with visual blocks and wires while keeping the full Python code accessible for customisation
• Check You open a block and change its Python. Where does that change live — in this flow, or in every flow using that block?
• Cost Still free: building and running flows locally costs nothing beyond your own machine and the model key you call.

2.3 Create a chatbot that answers from your PDFs or website

A template is a pre‑built flow you copy; the Document‑grounded starter wires up RAG so uploaded files are split, embedded and stored for retrieval before answering.

Do this first Inspect a flow on the canvas and view its code

Create a chatbot that answers questions using only the content you upload

Templates give you a working flow to start from instead of a blank canvas — the gallery includes starters like Content Search, Code Debugger, Basic Prompting, Basic Agent and Doc Assistant.

1. Open the template gallery and select the “Document‑grounded starter” template
2. Drag your PDF or website into the document loader block to load the source material
3. Click Playground, type a question that only the uploaded document can answer, and press Send

• You'll see A chatbot that replies with excerpts taken directly from your uploaded document
• Takeaway Templates give you a ready‑made RAG pipeline – load your files and the bot becomes grounded in your own data
• Check Your bot answered a question your PDF never mentions. What went wrong — the template, the file, or the question?
• Cost Free to build and run; you pay only the LLM (and any vector-DB) usage when the bot answers. Templates save you from wiring the flow from scratch.

2.4 Build the same RAG flow from a blank canvas

Building from scratch reveals the five core blocks of a RAG flow: Chat Input → Document Loader → Vector Store → Language Model → Chat Output.

Do this first Create a chatbot that answers from your PDFs or website

Rebuild the document‑grounded chatbot block by block, with no template, and see what each block contributes

Ask this in the Playground once the five blocks are wired — a term only your file contains proves the answer came from retrieval and not from the model’s own knowledge.

1. Click New Flow → Blank Flow to start from an empty canvas
2. Drag a Chat Input block, then a Document Loader block and point it at a local file
3. Add a Vector Store block and connect the loader’s output port to its input port
4. Add a Language Model block, paste your API key in its settings, and wire the vector store’s retrieval output into it
5. Add a Chat Output block, connect the model’s response to it, then open Playground and ask your question

• You'll see Five connected blocks on the canvas, and a Playground answer that quotes your own document with retrieved chunks visible when you expand the model block’s run view
• Takeaway A template is five blocks someone already wired — build it once yourself and every Langflow flow becomes readable
• Check Which of the five blocks is the one that makes the answer come from your document rather than the model?
• Cost Langflow is free and open-source (MIT). You pay the embedding call once per document plus one model call per question; the vector store is local unless you point it at a hosted one.

2.5 Swap model and vector store in a Langflow flow

Each block’s provider dropdown lets you swap underlying services without rewiring, so changing the LLM or vector store only requires updating a setting and its API key.

Do this first Build the same RAG flow from a blank canvas

Replace the LLM and vector database used by a flow with alternatives of your choice

Langflow is model-agnostic: the provider sidebar in the gallery (Anthropic, MistralAI, Langchain, Glean, Cohere, OpenAI, NVIDIA) hints at how many you can wire in.

1. Open the Model block’s settings
2. Select a different Provider from the dropdown list
3. Enter the new provider’s API Key
4. Open the Vector Store block’s settings
5. Choose an alternative Vector Database from its provider list

• You'll see The same flow answering through a different model provider after a one‑block swap
• Takeaway Model‑agnostic + bring‑your‑own‑keys lets you control cost and provider while Langflow remains free
• Check You swap the vector store on a flow that already answered questions. Why do the old answers stop working until you re‑load the documents?
• Cost Free to run; costs are whatever the model and vector-DB providers you wire in charge for usage. No lock-in to a single vendor.

2.6 Debug an agent in the Playground

The Playground acts as an interactive debugger, expanding each turn to show the agent’s reasoning trace, selected tool and the data exchanged.

Do this first Swap model and vector store in a Langflow flow

Inspect an agent’s step‑by‑step reasoning and tool choices to locate and fix faulty logic

The Playground is interactive — it shows the agent reasoning and choosing tools in real time, not just the final answer.

1. Open the Playground and send a message to start the flow
2. Observe the expanded reasoning trace and the highlighted tool selection for each step
3. Modify a block’s Role or instruction text, then re‑run the query in the Playground to verify the corrected behaviour

• You'll see A live trace showing each reasoning step and the tool the agent selects
• Takeaway Seeing the internal trace lets you target the exact block that failed
• Check The agent gave a confident wrong answer. Which part of the Playground trace tells you whether the model or the tool was at fault?
• Cost Free; Playground runs use only the model usage of each test message you send.

2.7 Export a flow as an API or MCP server

Exporting turns a finished flow into a callable service: a REST endpoint with code snippets, or an MCP server that other agents can invoke as a tool.

Do this first Debug an agent in the Playground

Turn your finished flow into something others can call by exporting it as a REST API or an MCP server with one click

The export dialog offers Run cURL, Python API, Python Code and JS API tabs — pick whichever fits how you'll call it.

12 Enlarge

1. 1 Python API tab copy snippet for external call
2. 2 Python Code tab copy code to run flow locally

Best viewed on desktop — tap Enlarge to read the numbered controls.

1. Open the flow’s API dialog from the top‑right menu
2. Copy a snippet from the Run cURL, Python API, Python Code or JS API tab and execute it outside Langflow
3. Click Export as MCP Server to make the flow available to other agents via the Model Context Protocol

• You'll see Your flow answering a request made from outside Langflow – it's now a callable service, not just a canvas
• Takeaway One click turns a flow into a REST API or MCP server – what you built on the canvas becomes a service others can use
• Check What is the difference between exporting a flow as an API and exporting it as an MCP server?
• Cost Free: exporting and self-hosting the API/MCP server costs only your own infrastructure plus the model usage per call.

2.8 Self-host Langflow so your exported flow has a home

Running Langflow as a server gives your exported endpoints a persistent address; the same application runs headless and serves flows over HTTP.

Do this first Export a flow as an API or MCP server

Run Langflow as a server you control and reach its API at an address other machines can call

brew install uv, then uv pip install langflow

Run this in a terminal on the machine that should host it — Python 3.10–3.14 and roughly 2 GB of free RAM. Drop --host 0.0.0.0 if it should only answer on that machine.

1. Install uv (or use pip) on the host machine and run uv pip install langflow
2. Start the server with langflow run; add --host 0.0.0.0 if remote access is required
3. Open a browser to http://localhost:7860 to verify the dashboard loads, then import your exported flow if needed
4. Re‑run the API call from the previous lesson against this address to confirm it answers from the server

• You'll see The terminal prints the listening address, the dashboard loads in a browser, and your exported API call returns the same answer as locally
• Takeaway An exported flow is only as durable as the server behind it — self‑hosting turns a demo endpoint into one you can depend on
• Check Your exported API worked in the editor but 404s from another machine. What is missing?
• Cost The software is free (MIT) — you pay only for the machine it runs on and the LLM keys you put into it. A small VPS is enough; the model calls, not Langflow, are what cost money.