Cline + any OpenAI-compatible gateway: Base URL ends at /v1

Tue, 27 Oct 2026 09:22:37 +0000

Cline (the independent VS Code / JetBrains coding agent — not affiliated with this post) has a first-party “OpenAI” provider and a separate OpenAI Compatible provider. For a custom gateway you want the second one.

1. Smoke-test outside the IDE

export LLM_API_KEY='…'
export LLM_BASE_URL='https://api.china-aiapi.com/v1'

curl -sS "$LLM_BASE_URL/models" -H "Authorization: Bearer $LLM_API_KEY" | head

Pick a MODEL_ID that appears in that list.

2. Cline settings

API Provider → OpenAI Compatible
Base URL → https://api.china-aiapi.com/v1 (stop at /v1; do not append /chat/completions)
API Key → value of $LLM_API_KEY (no Bearer prefix)
Model → MODEL_ID
Open Model Configuration and set context window / max tokens yourself; custom providers do not infer them

3. Optional CLI shape (if your Cline build ships cline auth):

cline auth -p openai -k "$LLM_API_KEY" -b "$LLM_BASE_URL" -m "MODEL_ID"

Troubleshooting

Symptom → Likely cause
404 on chat → Base URL missing /v1 or has an extra /v1/v1
401 → Key not exported / pasted with trailing space
Model not found → MODEL_ID ≠ an id from /models
Tiny context / early cuts → Model Configuration left at defaults

Happy to compare notes if anyone is wiring Cline through a corporate OpenAI-compatible proxy instead of a hosted gateway.

Disclosure: I work on the APIGOTO team; independent of OpenAI, Anthropic and Google. Cline is an independent product. Example gateway used above is ours (pay-as-you-go, logs only if enabled in settings): www.china-aiapi.com · https://api.china-aiapi.com/v1

Automated PR Reviews with Cline and NVIDIA NIM APIs

Tue, 06 Oct 2026 11:57:57 +0000

AI has been evolving at a breakneck pace ever since the first consumer-facing products landed. I've been updating my personal development workflow since day one, keeping my tools and habits aligned with each new wave of progress.

Over time I've worked with a long list of models and tools.

Models

ChatGPT
Claude
Gemini

Tools

Cursor
GitHub Copilot for VS Code
GitHub Copilot for Xcode
Xcode Coding Intelligence
Trae
VS Code plugins: Cline, Roo Code, …

…and the list keeps growing.

For the last year or so I've been developing with TRAE / Gemini on macOS, and both the IDE and the model served me well. But those tools and models come with two recurring pain points:

Third-party apps mean your data sits in someone else's database.
Subscription fees can add up fast.

The natural answer to both is local LLMs. I tested that route on my MacBook M1 Pro with LM Studio, pulling models locally and wiring them into VS Code / Xcode:

Gemma
Qwen

…and a few others.

The honest result: on my hardware, local models weren't strong enough to beat the cloud subscription experience.

Then, a few days ago, I discovered that NVIDIA is running open models on its own servers for free at build.nvidia.com. I immediately wanted to try my workflow against that service — first with the NVIDIA NIM Provider extension in VS Code, then side-by-side with Cline. The Cline + NVIDIA NIM combo turned out to be noticeably more stable, so that's what stuck.

I was about to undergo a major refactor on one of my projects TaxCalculator: turning the Flask/Python monolith (thousands of lines in index.html plus a tangled frontend) into a sliced, testable, readable, and maintainable structure.

That result genuinely made my day.

Just before merging the refactor PR, one more question popped into my head: Cline + NVIDIA NIM had carried me this far — could the same duo review my PRs automatically through GitHub Actions?

Spoiler: yes, it can. Here's the full story, including the bumps along the way.

Why Automated PR Review?

I'm already constantly reviewing AI-generated code during development and again at PR time. Adding a third pass — an automated PR review bot — is the obvious next step for both security and robustness, right? An LLM-based agent is especially good at catching:

Domain-specific rules (Clean Architecture, Decimal for money, no hardcoded secrets)
Edge cases / null-safety issues
Test coverage gaps
API & architecture inconsistencies

Cline CLI is ideal for this: it runs headless, integrates with gh, and supports any OpenAI-compatible API.

Architecture

PR opened → GitHub Actions workflow triggers
          → Diff fetch (1 API call, capped by context budget)
          → Cline CLI: read review rules + analyze diff
          → gh pr review --comment to leave inline feedback

Three files do the work:

File	Role
`AGENTS.md`	Universal review rules (same across every project: language, secrets, dependencies, naming, commits)
`.clinerules/taxcalculator.md`	Project-specific rules (Clean Arch boundaries, `Decimal`, zero-data-retention, mandatory Flask blueprints, `LoggerService`, `ConcurrencyService`)
`.github/workflows/cline-pr-review.yml`	CI workflow

Why two rule files? So I can copy AGENTS.md verbatim into other projects. Cline auto-loads anything inside .clinerules/ natively — no extra config needed.

Step-by-Step Setup

1. Add the secret

In the GitHub repo go to Settings → Secrets and variables → Actions and add:

NVIDIA_API_KEY = your key from build.nvidia.com

2. Write the workflow file

on:
  pull_request:
    types: [opened, ready_for_review, synchronize]

jobs:
  cline-review:
    runs-on: ubuntu-latest
    timeout-minutes: 25
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '24' }
      - run: npm install -g cline

      - name: Authenticate Cline with NVIDIA NIM
        env: { NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }} }
        run: |
          cline auth --provider openai \
            --apikey "$NVIDIA_API_KEY" \
            --baseurl "https://integrate.api.nvidia.com/v1" \
            --modelid "minimaxai/minimax-m3"

The 6 Problems I Hit (and how I fixed them)

1. Node 20 deprecation

Error: Node.js 20 is deprecated... being forced to run on Node.js 24
Fix: node-version: '24' (Cline CLI also requires Node 22.15+ for TLS trust store).

2. `unknown option '--base-url'`

Error: cline CLI does not accept dashed flags for this option.
Fix: Drop the dash: --baseurl "https://integrate.api.nvidia.com/v1".

3. `auth quick setup requires --modelid`

Error: quick-setup mode forces you to pick a model.
Fix: Add --modelid "minimaxai/minimax-m3".

4. `429 Too Many Requests` (rate limit)

Problem: NVIDIA's free tier caps you at 40 requests per minute. Every time Cline reads a slice of the diff, that's one request to the LLM. A large diff made Cline fetch it in several chunks, passing the 40 limit in under a minute — as a result the API responded with HTTP 429 and stopped serving.

Fix — two layers:

(a) Diff pre-preparation in the workflow, not in Cline:
Fetch the full diff once, cap it by a budget derived from the model's context window, and derive the file list locally. Cline then just cats the prepared files — one read, one request.

- name: Prepare PR diff
  env:
    MODEL_CONTEXT_WINDOW: "128000"   # token limit of the model
    DIFF_BUDGET_RATIO: "0.7"         # share of context for the diff
    DIFF_TOKENS_PER_LINE: "3"        # avg token density of a unified diff
  run: |
    # Fetch the diff once. Each subsequent read by Cline would be another
    # LLM call, burning our 40 RPM budget.
    gh pr diff "$PR" > /tmp/diff_full.txt
    TOTAL_LINES=$(wc -l < /tmp/diff_full.txt)

    # Derive the line cap from the model's context window. This is NOT a
    # magic number — change MODEL_CONTEXT_WINDOW to retarget a different model.
    MAX_LINES=$(awk -v ctx="$MODEL_CONTEXT_WINDOW" -v ratio="$DIFF_BUDGET_RATIO" \
                   -v tpl="$DIFF_TOKENS_PER_LINE" \
                   'BEGIN { printf "%d", ctx * ratio / tpl }')

    # Truncate to the cap. Anything beyond is dropped with a GitHub Actions
    # warning annotation so reviewers see why.
    if [ "$TOTAL_LINES" -le "$MAX_LINES" ]; then
      cp /tmp/diff_full.txt /tmp/diff.txt
    else
      head -"$MAX_LINES" /tmp/diff_full.txt > /tmp/diff.txt
      echo "::warning::Diff truncated from $TOTAL_LINES to $MAX_LINES lines"
    fi

    # Build the file list locally from 'diff --git' headers — no extra API call.
    grep '^diff --git' /tmp/diff_full.txt | sed -E 's|^diff --git a/(.+) b/.*|\1|' \
      > /tmp/diff_summary.txt

(b) Strict prompt budget — max 5 tool calls, gh pr diff banned:
Without these rules, an LLM agent will happily re-fetch the diff, read extra files for "context", and burn through your rate budget. We tell Cline exactly what we want it to do, in what order, and how many steps it's allowed to take.

- Do NOT call 'gh pr diff' again.
- Make at most 5 tool calls total.
- Read /tmp/diff_summary.txt and /tmp/diff.txt via 'cat'.
- Post all review comments in ONE 'gh pr review --comment' call.

5. `unknown flag: --stat`

Error: gh pr diff --stat does not exist in this gh version (only --name-only and --patch).
What we wanted it for: the "X files changed, +Y −Z" summary you see on the PR page. We needed that list so Cline could see the affected files before reading the diff.
Fix: Extract the file list locally from the diff --git a/... b/... headers in the diff itself. No extra API call, just text processing:

grep '^diff --git' /tmp/diff_full.txt | sed -E 's|^diff --git a/(.+) b/.*|\1|'

6. Retries duplicate findings

Symptom: On a transient 429 or socket drop, naively adding || sleep 60 && retry seems safe. In practice it isn't — Cline is invoked as a fresh CLI process each time, so the retry restarts from scratch: re-reads the diff, re-reads context, and posts duplicate review comments on the same PR.
Fix: No retry. Run Cline once, fail loudly on failure. If a future change makes retries necessary, persist Cline's intermediate state to disk between attempts so a retry can resume.

# No retry — Cline must complete in one session.
cline --auto-approve true "$PROMPT" \
  || (echo '::error::Cline review failed'; exit 1)

How We Pick the Dynamic Line Limit

The cap is not a magic number. It's derived from three constants the workflow exposes as environment variables:

Variable	Default	Why
`MODEL_CONTEXT_WINDOW`	`128000`	Token limit of the model you call
`DIFF_BUDGET_RATIO`	`0.7`	Share of the context reserved for the diff
`DIFF_TOKENS_PER_LINE`	`3`	Average token density of a unified diff

The formula:

max_lines = context_window × diff_budget_ratio ÷ diff_tokens_per_line
         = 128_000 × 0.7 ÷ 3
         ≈ 29_866 lines

So a typical PR with fewer than ~30k diff lines is reviewed in full. Anything larger is truncated and the workflow emits a ::warning:: annotation explaining the cap.

Why not "unlimited"? Three real upper bounds apply, and any of them can break the run:

Model context window — the diff, system prompt, rules, and the agent's output all share one token budget. Overflow = truncated reasoning or broken output.
Workflow timeout — the job-level timeout-minutes caps the total runtime. A multi-hundred-thousand-line diff cannot finish reviewing inside the window.
Rate limit — free NVIDIA NIM caps at 40 RPM. A giant diff turns into many LLM calls if the agent reads it in pieces.

Trade-offs you can tune:

DIFF_BUDGET_RATIO = 0.9 → bigger diff, less room for Cline's reasoning/output.
DIFF_BUDGET_RATIO = 0.5 → smaller diff, larger safety margin.
timeout-minutes → increase for very large diffs, decrease for faster feedback.
Switch models → set MODEL_CONTEXT_WINDOW (e.g. 32000) and the cap recomputes automatically.

Result: A Real PR Review

On a real PR, the workflow produced output like this:

🚨 Critical: duplicate block in report_service._create_trades_from_lists, hard-coded strings, remember=True cookie leaking across sessions
⚠️ Important: privacy/data-retention violation (cvs_hash persisted server-side), missing integration tests under tests/unit/parsers/, architecture inconsistencies
✨ Nits: quote style inconsistency, NonJSON typo, multi-line logs

In other words: universal rules + project-specific rules + single-shot review + dynamic diff budget combined into a real, value-adding automated review running on a free tier.

Real Example: TaxCalculator Refactor (PR #13)

Here's an actual PR review generated by the workflow on my TaxCalculator project — a large refactor turning a Flask monolith into Clean Architecture boundaries.

PR Review — eraydiler/TaxCalculator#13

Overall the PR is a large refactor that improves structure (Clean Architecture boundaries, partials, JS modules, tests). However, several blocking issues need attention before merging.

🔴 Blocking — Privacy: zero-data-retention claim is violated

ARCHITECTURE.md (and README.md) explicitly promise "No user report data (CSV content, tax summary) is persisted on the server. All report data lives exclusively in the clients IndexedDB." The diff contradicts this:

src/models/report_task.py stores csv_content on the model:

self.csv_content: Optional[str] = task_data.get("csv_content")
...
"csv_content": self.csv_content,

src/repositories/mongo_task_repository.py writes csv_content to MongoDB:

if csv_content is not None:
    update_data["csv_content"] = csv_content

src/blueprints/auth.py (download_csv) reads task.csv_content from MongoDB and serves it.

The project-specific rule Privacy: Server must NOT persist CSV report content or tax summaries is being broken by this change. Either:

Remove csv_content from ReportTask and persist only csv_hash (the documented design), and make the client responsible for retaining the CSV in IndexedDB for re-download — or —
Update ARCHITECTURE.md / README.md to reflect the actual policy, and get explicit sign-off, since this is a documented user-facing privacy guarantee.

🟡 Logic / Security

src/blueprints/auth.py: the upload endpoint computes csv_hash for integrity but never compares the stored hash against a client-supplied hash on download — the integrity check described in ARCHITECTURE.md is one-directional only. If you keep csv_content in Mongo, at least verify hash equality before serving.
The webhook signature path uses X-Signature header; confirm this matches Lemon Squeezy's actual header name (X-Signature is correct for Lemon Squeezy — OK, but worth a comment).
tests/unit/test_webhook_idempotency.py patches src.app.payment_service.user_repository but the production code accesses the repo via the service, not the module-level attribute. Verify the patch target; otherwise this test passes without exercising the real path.

🟡 Tests

New tests added (good), but no unit test exists for the refactored mongo_task_repository create_task_metadata / update_task_status paths. Add coverage under tests/unit/ for both the success path and the privacy rule (assert that no csv_content is written when the zero-retention policy is enforced).
The download-race-condition test should also assert that csv_content is never written by the server, to lock in the privacy guarantee.

🟢 Minor / Style

tests/integration/test_end_to_end.py still contains print(...) debug noise (print("\nRow differences found:") etc.). Replace with LoggerService per the logging rule.
src/blueprints/auth.py returns {"error": "Geçersiz dosya formatı..."} — user-facing strings must be English unless localization is added; this is Turkish. Same applies to any other tr-string errors in the diff.
Commit messages are clean and descriptive — good.

✅ Looks good

Decimal is used consistently for monetary values (no float introduced for tax/money).
Blueprints live under src/blueprints/, not inline in app.py.
ConcurrencyService is used for parallel work.
LoggerService is used for errors/info.
JS is split into focused ES modules with proper single-responsibility boundaries.

Please address the Blocking privacy item first — it directly violates a documented user-facing promise and a project-specific review rule.

Lessons Learned

LLM agents are not cheap — even 40 RPM is tight, careful budgeting is essential.
CLI flags drift across versions — always check --help before writing the workflow.
Batch in the workflow, not in the agent — pre-preparation saves API calls.
Don't retry blindly — a fresh Cline process restarts from scratch and duplicates findings.
Keep universal rules separate from project-specific rules — reusable vs portable.
Derive magic numbers from real constraints — context window, timeout, rate limit — instead of guessing.
Real PR reviews catch real problems — the privacy violation in TaxCalculator#13 would have been missed by manual review alone.

Coder Legion - Recent posts tagged cline