AI

Langflow MCP Server for Claude Code with Ollama Local Models

Want Claude Code to call one of your Langflow flows as a tool, with the prompt and the data staying on your own box? A Langflow MCP server for Claude Code does exactly that, because every Langflow project publishes its flows as MCP tools that Claude Code can reach over streamable HTTP with an x-api-key header. The part nobody writes down is the Claude Code side, since the Langflow MCP docs stop at a generic client JSON built around uvx mcp-proxy.

Original content from computingforgeeks.com - post 187717

We built the whole chain on a lab VM. An Ollama service joins the hardened Langflow Docker Compose stack with Postgres, a flow runs on a local qwen3 model, the project exposes that flow as an MCP server, and Claude Code calls it through nginx with a TLS certificate from certbot. Several things broke on the way, and the small model got a fact wrong that Claude Code caught; you will find both below. I ran through this on an Ubuntu 26.04 VM with Langflow 1.13.2 and Ollama 0.40.16 in November 2026, and it works end to end.

Step 1: Start from the hardened stack

This guide adds to a working stack instead of building one, so start from the hardened stack in 186186, the post number of our hardened Langflow Docker Compose guide. That post covers Postgres, the superuser password, auto-login off, nginx with basic auth in front of every path, and the certbot sidecar. We reused its files and changed only what this article shows, plus the Langflow image tag, so if your stack differs, compare against that one first.

Before you add a model, check that your host has what the stack and Claude Code expect:

  • Docker Engine with the Compose plugin
  • A DNS name with an A record pointing at the host
  • Ports 80 and 443 open, nothing else
  • About 4 GB of RAM free for Langflow plus a 2B model
  • Claude Code on the workstation that will call the tool

The RAM figure comes from our own run, not a vendor sheet: docker stats showed Langflow at 1.3 GiB and Ollama at 1.9 GiB with qwen3:1.7b loaded, while Postgres and nginx used about 60 MiB together. Our lab VM had 8 vCPUs and 32 GB, which is a comfortable floor for testing. A bigger model needs more of both, and every concurrent tool call queues for the same CPU, so size the box for the model you actually plan to run.

If your stack already serves HTTPS, skip this command, because the running proxy holds port 80 and the certificate exists. On a fresh host the certificate comes first, the same way as in the hardened guide: with port 80 still free and the A record in place, the standalone certbot container wrote the files nginx mounts:

docker run --rm -p 80:80 -v "$PWD/certs:/etc/letsencrypt" certbot/certbot certonly --standalone -d langflow.example.com --agree-tos --register-unsafely-without-email --no-eff-email

Replace langflow.example.com with your own name here and in the nginx config. We tested with a publicly trusted certificate only, so a self-signed one was not part of this run.

Step 2: Add an Ollama service to the Compose file

Ollama runs as a fifth service on the same Compose network, with no published port. Langflow reaches it by service name at http://ollama:11434, and nothing outside the host can talk to the model directly. That keeps the attack surface the same as before: nginx is still the only thing listening on a public interface.

Open the Compose file you already have:

sudo vim docker-compose.yml

Add the ollama service under services: and its volume under volumes:. These lines are copied from the file we deployed:

  ollama:
    image: ollama/ollama:0.40.16 # pin: tested release for this guide #https://github.com/ollama/ollama/releases
    restart: unless-stopped
    volumes:
      - ollama-models:/root/.ollama

volumes:
  ollama-models:

The langflow service changes too. Our image tag moved to the newer patch release we tested, so if you bump yours, follow the login-preserving upgrade steps in the hardened guide first. Beyond the tag, two lines change. The depends_on entry makes Compose start Ollama first, and the environment line tells Langflow that the hostname ollama is allowed even though it resolves to a private address. Without that second line, Langflow refuses to save the model provider, which is the first error we hit in Step 3:

  langflow:
    image: langflowai/langflow:1.13.2 # pin: tested release for this guide #https://github.com/langflow-ai/langflow/releases
    depends_on:
      langflow-db:
        condition: service_healthy
      ollama:
        condition: service_started
    environment:
      - LANGFLOW_SSRF_ALLOWED_HOSTS=ollama

Keep the rest of the environment block from the hardened stack as it is; the snippet only shows the line to add. Bring the stack up, then pull a model into the Ollama volume. We used qwen3:1.7b because it answers in seconds on CPU, and Langflow tags it as tool-capable for when you build agent flows later:

docker compose up -d
docker compose exec ollama ollama pull qwen3:1.7b

Then confirm two things: the model is on disk, and the Langflow container can reach Ollama by name. The second check is the one that matters, because it proves the Compose network path Langflow will use:

docker compose exec ollama ollama list
docker compose exec langflow curl -s http://ollama:11434/api/version

Our run listed the 1.4 GB model and answered with the Ollama version, and all five services were up with Postgres healthy.

Docker Compose stack with Langflow, Postgres, Ollama, nginx and certbot running and qwen3:1.7b pulled

If the version call prints nothing, curl could not resolve ollama, which means Langflow and Ollama are not on the same Compose project network. That usually happens when the Ollama service went into a different file. Keep both in one docker-compose.yml and you avoid the problem entirely.

Step 3: Point Langflow at the Ollama service

Langflow keeps model credentials in one place now, so you configure Ollama once and every Language Model component you drop on a canvas can pick its models. Log in, open the profile menu, choose Settings, then Model Providers. Select Ollama, type http://ollama:11434 into Ollama Base URL, and click Save.

Langflow Model Providers settings with Ollama selected and the base URL set to http://ollama:11434
  1. 1Ollama
  2. 2Ollama Base URL
  3. 3Save

Why not keep the placeholder http://localhost:11434 in that field? Because inside the Langflow container, localhost is the Langflow container itself, so the provider would never find a model. The service name is the address that works for you.

On our first try, before the environment line from Step 2 existed, Save failed with a red message under the field. Langflow resolves the hostname, sees a private Docker address and blocks it as a possible server-side request forgery target.

Langflow error: Hostname ollama resolves to blocked IP address, add it to LANGFLOW_SSRF_ALLOWED_HOSTS

The message names the fix itself, which is rare for an error. Add LANGFLOW_SSRF_ALLOWED_HOSTS=ollama to the Langflow environment, run docker compose up -d again so the container is recreated, and save the provider a second time. Allow only the service name, not a whole private range, so the guard keeps doing its job for every other URL a flow might fetch.

With the variable in place, the provider saved and the model list showed qwen3:1.7b with its tool tag.

Ollama provider saved in Langflow with qwen3:1.7b listed as a tool-capable language model

Only models you have pulled show up in that list, so pull first and configure second. If you pull another model later, you will see it here without another save.

Step 4: Build the flow to expose

A flow becomes an MCP tool only when it ends in a Chat Output component, so the simplest useful shape is Chat Input, a Prompt Template, a Language Model and Chat Output. Langflow ships that exact shape as the Basic Prompting template. Create a new flow, choose Browse more…, then Basic Prompting. With Ollama configured, the Language Model component picked qwen3:1.7b on its own in our run.

We turned it into a summarizer for incident notes and changelogs, because that is a job Claude Code can hand off cheaply while it keeps its own context for the code. Replace the text in Template with your instructions. This is the prompt we used, including the /no_think switch that stops qwen3 from printing its reasoning into the answer:

You summarize incident notes and changelogs for an ops team. Reply with exactly three short bullet points: what changed, what is affected, and the one action to take. Do not add a preamble. /no_think

Then click the flow name at the top and give it a name and a description. Both matter more than they look. The name becomes the tool name, and the description becomes the text Claude Code reads when it decides whether to call the tool, so write it for that reader. We named ours ops-notes-summarizer and described it as a tool that summarizes incident notes or a changelog into three bullets with a local Ollama model.

Langflow ops-notes-summarizer flow with a Prompt Template and a Language Model on Ollama qwen3:1.7b
  1. 1Template
  2. 2Language Model
  3. 3ops-notes-summarizer

Send a test message from the Playground before you go further, so you know the model answers. If the flow does not answer there, it will not answer over MCP either, and the Playground shows the component that failed.

Step 5: Expose the project as an MCP server

Every Langflow project is already an MCP server, and you only choose which flows it offers and how clients authenticate. Go back to the project and open the MCP Server tab. It gives you three things to check before any client connects:

  • The tools list under Flows/Tools
  • Edit Tools, to hide flows from clients
  • The auth line and its Add Auth button

Make sure OPS_NOTES_SUMMARIZER is listed, and switch off any flow you do not want Claude Code to see. Then look at the auth line, because ours said something alarming.

Langflow project MCP Server tab listing OPS_NOTES_SUMMARIZER with Auth None (public)
  1. 1MCP Server
  2. 2OPS_NOTES_SUMMARIZER
  3. 3Add Auth

The tab read Auth: None (public) on a server with auto-login off. Was the endpoint really open? We probed the endpoint on the loopback port before trusting that label, and the server disagreed with its own UI: a request with no key came back 401 with {"detail":"API key required for this project. Provide x-api-key header or query parameter."}. So the default state is safe, and the label is wrong.

The trap is what happens when you click around. We opened Add Auth, selected None and saved, and the same unauthenticated request then returned 200. An explicit None really is public. Pick API Key instead and click Save, which pins the project to key auth whatever the label said before.

Configure MCP Server Authentication dialog in Langflow with API Key selected
  1. 1API Key
  2. 2Save

After the save, the tab shows Auth: API Key and the JSON panel adds the --headers x-api-key YOUR_API_KEY arguments. Copy the project ID from the end of the URL in that JSON, the long UUID before /streamable, because you need it in Step 6.

Langflow MCP Server tab after switching to API Key auth, with the streamable HTTP client JSON

Now create the key. You can do it under Settings and Langflow API Keys, but we did it from the Docker host over the loopback port so the key never passes through a browser. First log in as the superuser and keep the token:

source .env
TOKEN=$(curl -s -X POST http://127.0.0.1:7860/api/v1/login \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "username=langflowadmin" \
  --data-urlencode "password=${LANGFLOW_SUPERUSER_PASSWORD}" \
  | python3 -c 'import json,sys; print(json.load(sys.stdin)["access_token"])')

Then ask for a key named after the client that will use it, so you can revoke it later without guessing:

curl -s -X POST http://127.0.0.1:7860/api/v1/api_key/ \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"name": "claude-code"}'

Our first attempt did not return a key at all. It returned this, which is the second error of the build:

{'detail': 'Fernet key must be 32 url-safe base64-encoded bytes.'}

Langflow encrypts API keys with LANGFLOW_SECRET_KEY through the Fernet library, and our .env held the output of openssl rand -hex 32, as the hardened stack generates it. Hex is not URL-safe base64, so login worked and key creation failed. The Langflow docs generate the value with token_urlsafe from the Python secrets module instead:

python3 -c "from secrets import token_urlsafe; print(token_urlsafe(32))"

Put that value in LANGFLOW_SECRET_KEY in .env, recreate the container with docker compose up -d langflow, log in again and repeat the request. This time the response carried the key:

{
  "name": "claude-code",
  "last_used_at": null,
  "total_uses": 0,
  "is_active": true,
  "expires_at": null,
  "id": "178492d5-69f7-4fe0-92a3-392acf1e8b49",
  "api_key": "sk-nzc6...redacted",
  "user_id": "906e5da5-79f0-4614-bbb2-e0cce0d12dc1"
}

Copy the full api_key value now, because Langflow will not show it again. Our Ollama provider setting and the flow both survived the secret key change, but if you already stored credential variables under the old key, use the rotation procedure in the Langflow docs rather than swapping the key by hand.

Step 6: Let the MCP path through nginx

The hardened stack puts basic auth on every path, including /api/v1/mcp, so a client that sends only the Langflow key gets turned away by nginx before Langflow sees it. We tested both ways through: keep basic auth everywhere and send two headers from Claude Code, or exempt the project MCP path from basic auth and rely on the x-api-key alone.

The first option needs no proxy change at all. Langflow ignores the Authorization: Basic header and reads only x-api-key, so both credentials travel side by side, which Step 7 shows. It is the stricter choice, and the one we would keep for a server on the open internet with a single client.

The second option is cleaner when several people or tools call the server, because each gets its own revocable Langflow key and nobody shares the edge password. Open the nginx config:

sudo vim nginx.conf

Add this location inside the listen 443 server block, above the existing location /. The if line refuses any request that carries no key at all, so even a project someone later switches to None stays closed at the edge. It also means a client that passes the key as the x-api-key query parameter, which Langflow accepts, gets the nginx 401, so send it as a header:

    # Project MCP servers: Langflow's x-api-key gates them, so basic auth is off here.
    location /api/v1/mcp/project/ {
        auth_basic off;
        if ($http_x_api_key = "") {
            return 401;
        }
        proxy_pass http://langflow:7860;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_buffering off;
        proxy_cache off;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_read_timeout 3600s;
    }

The streaming lines are the part MCP depends on. Streamable HTTP and the SSE fallback both send text/event-stream responses, so proxy_buffering off and the long read timeout keep nginx from holding events back or closing a slow tool call. Neither transport needed WebSocket upgrade headers in our run; both worked as plain HTTP/1.1 to the upstream. Test the syntax and reload:

docker compose exec proxy nginx -t
docker compose exec proxy nginx -s reload

Now prove it from your workstation. Set the values the rest of this guide uses once, with your own project ID, Langflow key and edge password, so every command copies cleanly:

export LANGFLOW_PROJECT_ID="b32684d4-f0be-4f7b-8a06-854d411f95ba"
export LANGFLOW_API_KEY="sk-your-langflow-key"
export EDGE_PASS="your-edge-password"
export MCP_URL="https://langflow.example.com/api/v1/mcp/project/${LANGFLOW_PROJECT_ID}/streamable"
INIT='{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'

Four requests cover the cases that matter. No key, a wrong key and the rest of the site must all fail, and only the real key may pass:

curl -s -o /dev/null -w "%{http_code}\n" -X POST "${MCP_URL}" -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" -d "${INIT}"
curl -s -X POST "${MCP_URL}" -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" -H "x-api-key: sk-wrong" -d "${INIT}" -w ' %{http_code}\n'
curl -s -o /dev/null -w "%{http_code}\n" -X POST "${MCP_URL}" -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" -H "x-api-key: ${LANGFLOW_API_KEY}" -d "${INIT}"
curl -s -o /dev/null -w "%{http_code}\n" https://langflow.example.com/api/v1/flows/

Our run, in the same order.

curl probes against the Langflow MCP path through nginx: 401 without key, 401 wrong key, 200 valid key

The answers tell you who refused. The empty request got the nginx 401, the wrong key got the Langflow answer {"detail":"Invalid API key"}, the real key got 200, and /api/v1/flows/ still wanted the basic-auth pair. If the real key also gets an HTML 401 page from nginx, the location is in the wrong server block, which is exactly where ours landed first.

Step 7: Add the Langflow MCP server to Claude Code

Claude Code talks to the project server directly over streamable HTTP, so you do not need uvx or mcp-proxy on the workstation, only the variables you exported in Step 6. With the nginx exemption in place, one header is enough. We registered the server in user scope so it is available in every project on the workstation:

claude mcp add --transport http --scope user langflow "${MCP_URL}" --header "x-api-key: ${LANGFLOW_API_KEY}"

Claude Code echoes the headers back redacted, so the key does not land in your scrollback. Then check the connection:

claude mcp list

The health check reported the server connected:

Checking MCP server health…

langflow: https://langflow.example.com/api/v1/mcp/project/b32684d4-f0be-4f7b-8a06-854d411f95ba/streamable (HTTP) - ✔ Connected

If you kept basic auth on the MCP path instead, the same command with only the key fails, and the failure is easy to misread as a bad Langflow key. Ours printed a red cross with Failed to connect and HTTP 401, and the 401 came from nginx. Add the basic-auth pair as a second header, built from the edge user and password:

EDGE_B64=$(printf 'langflowviewer:%s' "${EDGE_PASS}" | base64 | tr -d '\n')
claude mcp add --transport http langflow "${MCP_URL}" --header "Authorization: Basic ${EDGE_B64}" --header "x-api-key: ${LANGFLOW_API_KEY}"

The capture shows both runs, the 401 with one header and the connected server with two.

claude mcp list failing with HTTP 401, then connected after adding Basic auth and x-api-key headers

That second form went into local scope, the default. Where the entry lands decides who else can read your key, so pick the scope on purpose:

  • local: ~/.claude.json, this project only
  • user: ~/.claude.json, every project you open
  • project: .mcp.json in the repository root

Avoid --scope project for a server that carries a key in its headers. That file is meant to be committed and shared, and Claude Code asks every teammate to approve its servers on first use, so your key would travel with the repository.

Now the call that matters. In an interactive session you ask Claude Code to use the tool in plain words and approve the call when it prompts. We ran it non-interactively with claude -p so the whole exchange left a transcript. The run read its server from an mcp.json holding the same entry claude mcp add created, in this shape:

{"mcpServers": {"langflow": {"type": "http", "url": "https://langflow.example.com/api/v1/mcp/project/b32684d4-f0be-4f7b-8a06-854d411f95ba/streamable", "headers": {"x-api-key": "sk-your-langflow-key"}}}}

That file holds the key in plain text, so keep it out of any repository and delete it when you are done. Then call the tool, allowing only that one tool:

claude -p "Use the ops_notes_summarizer tool from the langflow MCP server to summarize this incident note, then show me its bullets: Postgres 16.4 to 16.6 minor upgrade on db01 failed at 02:10 because the data volume hit 100 percent. WAL archiving to the NAS had stopped on Monday. We freed 40 GB, restarted archiving and reran the upgrade at 03:05; it finished clean. The Grafana disk alert was set at 95 percent and never fired because the panel used the wrong mount." --mcp-config mcp.json --strict-mcp-config --allowedTools mcp__langflow__ops_notes_summarizer --output-format stream-json --verbose

With the server registered in user scope as above, you can leave out --mcp-config and --strict-mcp-config; we kept them so the run could not pick up any other server. The tool name Claude Code uses is mcp__langflow__ops_notes_summarizer, the server name from claude mcp add joined to the tool name Langflow derived from the flow. This is what came back, with the stream events condensed to one comment line each:

Claude Code calling the Langflow ops_notes_summarizer MCP tool and flagging two mistakes in the local qwen3 summary

Read the transcript from the top, because it shows you each hop. The init event shows the langflow server connected, Claude Code loads the tool definition, then calls it with the note as input_value, and Langflow answers with two text items. Claude noticed the duplicate and printed the bullets once. The whole run took 30.4 seconds over three turns, most of it the CPU model writing its summary.

The more useful part is what Claude Code did with the answer. The 1.7B model reversed the cause, claiming the failed upgrade halted WAL archiving when the stopped archiving had filled the disk, and it told us to reschedule an upgrade that had already finished clean. Claude caught both against the original note and wrote a corrected summary. That is the right division of labour for you with a small local model: let it do the cheap first pass behind MCP, and keep the calling model in the loop to check it, or move the flow to a bigger model when the summaries feed anything automatic.

The same call is easy to reproduce without Claude Code when you need to tell a client problem from a server problem. Send tools/list and then tools/call as JSON-RPC with curl, adding the Accept: application/json, text/event-stream header that streamable HTTP requires. This is the tools/list request we ran:

curl -s -u "langflowviewer:${EDGE_PASS}" -X POST "${MCP_URL}" -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" -H "x-api-key: ${LANGFLOW_API_KEY}" -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' | sed -n 's/^data: //p' | python3 -m json.tool

It came back with one tool, its name lowercased from the flow name, and an input_value string argument:

{
    "jsonrpc": "2.0",
    "id": 2,
    "result": {
        "tools": [
            {
                "name": "ops_notes_summarizer",
                "description": "Summarize incident notes or a changelog into three bullets with a local Ollama model",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "input_value": {
                            "type": "string",
                            "description": "Message to be passed as input."
                        },
                        "session_id": {
                            "type": "string",
                            "description": "Optional session identifier used to persist conversation history across tool calls. Omit to start a new session."
                        }
                    },
                    "required": []
                }
            }
        ]
    }
}

One detail in the raw tools/call result is worth knowing if you write your own client: the response held the summary twice, as two text items in the content array, with isError false. Claude Code dropped the duplicate on its own, as the transcript above shows, but a script that joins every content item will print the answer twice.

Step 8: Fall back to SSE or mcp-proxy

Langflow also serves each project over the older SSE transport at the same path with /sse in place of /streamable. The Claude Code docs mark SSE as deprecated and say recent releases fall back to it on their own when a server refuses HTTP, so you should rarely register it by hand. A client that only speaks SSE still needs it, and the nginx config above already passes it through unbuffered. We registered it next to the HTTP entry to prove the path:

claude mcp add --transport sse langflow-sse "https://langflow.example.com/api/v1/mcp/project/${LANGFLOW_PROJECT_ID}/sse" --header "Authorization: Basic ${EDGE_B64}" --header "x-api-key: ${LANGFLOW_API_KEY}"

Both entries reported connected in the same health check:

langflow: https://langflow.example.com/api/v1/mcp/project/b32684d4-f0be-4f7b-8a06-854d411f95ba/streamable (HTTP) - ✔ Connected
langflow-sse: https://langflow.example.com/api/v1/mcp/project/b32684d4-f0be-4f7b-8a06-854d411f95ba/sse (SSE) - ✔ Connected

For desktop clients that only launch stdio servers, the JSON on the MCP Server tab wraps the endpoint in mcp-proxy, a small bridge that speaks stdio on one side and streamable HTTP on the other. Its --headers flag takes a name and a value and can repeat, which is how you pass both credentials. We ran it on the Ubuntu host with pipx from the distro repository and fed it an initialize and a tools/list request on standard input:

sudo apt install -y pipx
pipx run mcp-proxy --transport streamablehttp --headers x-api-key "${LANGFLOW_API_KEY}" --headers Authorization "Basic ${EDGE_B64}" "${MCP_URL}"

mcp-proxy relayed both requests and printed the ops_notes_summarizer tool, with each upstream POST logged as 200 or 202 on standard error. In a client JSON file the same arguments go in the args array, and the Langflow docs warn against putting the key in the env object instead.

What broke in our lab

Every error below came from the lab run, in the order we hit it. The architecture we ended with is drawn here, with the first snag on the sketch.

Architecture diagram: Claude Code to nginx over HTTPS with x-api-key, Langflow MCP server, Ollama and PostgreSQL on one VM

The request path is short on purpose. Claude Code reaches nginx on 443, nginx hands the MCP path to Langflow on 7860, and Langflow calls Ollama on 11434 inside the Compose network.

Hostname ollama resolves to blocked IP address(es)

The SSRF guard in Langflow refuses any provider URL that resolves to a private address, and a Compose service name always does. The full message was Hostname ollama resolves to blocked IP address(es): 172.18.0.4. To allow this hostname, add it to LANGFLOW_SSRF_ALLOWED_HOSTS environment variable. Allow the single hostname as in Step 2 and recreate the container; a restart without recreate keeps the old environment.

Fernet key must be 32 url-safe base64-encoded bytes

API key creation failed while login and flows worked, because LANGFLOW_SECRET_KEY was 64 hex characters. Regenerate it with token_urlsafe(32) as in Step 5. The error only appears when Langflow first needs to encrypt something, which is why a stack can run for weeks before you see it.

claude mcp list: Failed to connect, HTTP 401

This was nginx basic auth, not Langflow. Look at the body of the 401 with curl: nginx answers with an HTML page titled 401 Authorization Required, while Langflow answers with JSON naming the API key. Send both headers or add the exempt location from Step 6.

A valid key still got the nginx 401 page

Our first edit put the MCP location in the port 80 server, above the first location / in the file. The 443 server never saw it and kept asking for basic auth. nginx -t passed because the config was valid, just useless. Run docker compose exec proxy nginx -T and read the 443 block to confirm where the location ended up.

Auth: None (public) on a server that requires a key

Not an error, but the most dangerous thing on the page. The default state enforced the key despite the label, and saving None explicitly made the endpoint public. Set API Key on purpose, and keep the nginx if check as a second lock.

Local model speed on CPU

Speed is the honest cost of keeping the model local, and you should know the number before you hand the tool to Claude Code. On 8 CPU cores with no GPU, the first tools/call against qwen3:1.7b took 19.5 seconds, including loading the model, and the next two took 15.8 and 9.5 seconds. That is fine for a summary you wait on once per task, and too slow for a tool your agent calls in a loop.

Four settings decide how long you wait, or how long Langflow waits for you:

  • Model size: stay at 1.7B to 4B on CPU
  • A GPU passed to the Ollama service
  • /no_think on qwen3 prompts
  • LANGFLOW_MCP_TOOL_EXECUTION_TIMEOUT, 180 seconds by default

If you move to a larger model, raise the Langflow tool timeout before you raise anything in nginx, because the 3600 second proxy timeout is already far above it. Our Ollama commands cheat sheet covers pulling and unloading models, and for heavier serving the vLLM production install exposes an OpenAI-compatible endpoint that the Langflow model providers list as well. Other ways to run the model itself are in our guide to running a local LLM with llama.cpp, and the rest of the MCP commands sit in the Claude Code cheat sheet. When the next Langflow release lands, upgrade with the login-preserving steps in the Langflow hardening guide, and re-run claude mcp list afterwards to confirm the tool is still connected.

Keep reading

Ollama Models Cheat Sheet: Best Models by VRAM, Tested (PDF) AI Ollama Models Cheat Sheet: Best Models by VRAM, Tested (PDF) Open Source LLM Comparison Table (2026) AI Open Source LLM Comparison Table (2026) Claude Code Cheat Sheet: Commands, Shortcuts and Flags (PDF) AI Claude Code Cheat Sheet: Commands, Shortcuts and Flags (PDF) Dual GPU LLM Build: PCIe x8/x8 vs x16/x4, PSU and Cooling AI Dual GPU LLM Build: PCIe x8/x8 vs x16/x4, PSU and Cooling OpenCloud vs ownCloud vs Nextcloud: Tested on Identical VMs Cloud OpenCloud vs ownCloud vs Nextcloud: Tested on Identical VMs Backup Etcd data on OpenShift 4.x to AWS S3 Bucket Backup Backup Etcd data on OpenShift 4.x to AWS S3 Bucket

Leave a Comment

Press ESC to close